1 /* Asynchronous subprocess control for GNU Emacs.
3 Copyright (C) 1985-1988, 1993-1996, 1998-1999, 2001-2012
4 Free Software Foundation, Inc.
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
29 #include <sys/types.h> /* Some typedefs are used in sys/file.h. */
39 /* Only MS-DOS does not define `subprocesses'. */
42 #include <sys/socket.h>
44 #include <netinet/in.h>
45 #include <arpa/inet.h>
47 /* Are local (unix) sockets supported? */
48 #if defined (HAVE_SYS_UN_H)
49 #if !defined (AF_LOCAL) && defined (AF_UNIX)
50 #define AF_LOCAL AF_UNIX
53 #define HAVE_LOCAL_SOCKETS
58 #include <sys/ioctl.h>
59 #if defined (HAVE_NET_IF_H)
61 #endif /* HAVE_NET_IF_H */
63 #if defined (HAVE_IFADDRS_H)
64 /* Must be after net/if.h */
67 /* We only use structs from this header when we use getifaddrs. */
68 #if defined (HAVE_NET_IF_DL_H)
69 #include <net/if_dl.h>
79 # include <sys/stream.h>
80 # include <sys/stropts.h>
84 #include <netinet/in.h>
85 #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"
133 # define waitpid(pid, status, options) wait (status)
139 /* Work around GCC 4.7.0 bug with strict overflow checking; see
140 <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=52904>.
141 These lines can be removed once the GCC bug is fixed. */
142 #if (__GNUC__ == 4 && 3 <= __GNUC_MINOR__) || 4 < __GNUC__
143 # pragma GCC diagnostic ignored "-Wstrict-overflow"
146 Lisp_Object Qeuid
, Qegid
, Qcomm
, Qstate
, Qppid
, Qpgrp
, Qsess
, Qttname
, Qtpgid
;
147 Lisp_Object Qminflt
, Qmajflt
, Qcminflt
, Qcmajflt
, Qutime
, Qstime
, Qcstime
;
148 Lisp_Object Qcutime
, Qpri
, Qnice
, Qthcount
, Qstart
, Qvsize
, Qrss
, Qargs
;
149 Lisp_Object Quser
, Qgroup
, Qetime
, Qpcpu
, Qpmem
, Qtime
, Qctime
;
150 Lisp_Object QCname
, QCtype
;
152 /* Non-zero if keyboard input is on hold, zero otherwise. */
154 static int kbd_is_on_hold
;
156 /* Nonzero means don't run process sentinels. This is used
158 int inhibit_sentinels
;
162 Lisp_Object Qprocessp
;
163 static Lisp_Object Qrun
, Qstop
, Qsignal
;
164 static Lisp_Object Qopen
, Qclosed
, Qconnect
, Qfailed
, Qlisten
;
166 static Lisp_Object Qipv4
, Qdatagram
, Qseqpacket
;
167 static Lisp_Object Qreal
, Qnetwork
, Qserial
;
169 static Lisp_Object Qipv6
;
171 static Lisp_Object QCport
, QCprocess
;
173 Lisp_Object QCbytesize
, QCstopbits
, QCparity
, Qodd
, Qeven
;
174 Lisp_Object QCflowcontrol
, Qhw
, Qsw
, QCsummary
;
175 static Lisp_Object QCbuffer
, QChost
, QCservice
;
176 static Lisp_Object QClocal
, QCremote
, QCcoding
;
177 static Lisp_Object QCserver
, QCnowait
, QCnoquery
, QCstop
;
178 static Lisp_Object QCsentinel
, QClog
, QCoptions
, QCplist
;
179 static Lisp_Object Qlast_nonmenu_event
;
181 #define NETCONN_P(p) (EQ (XPROCESS (p)->type, Qnetwork))
182 #define NETCONN1_P(p) (EQ (p->type, Qnetwork))
183 #define SERIALCONN_P(p) (EQ (XPROCESS (p)->type, Qserial))
184 #define SERIALCONN1_P(p) (EQ (p->type, Qserial))
190 /* Number of events of change of status of a process. */
191 static EMACS_INT process_tick
;
192 /* Number of events for which the user or sentinel has been notified. */
193 static EMACS_INT update_tick
;
195 /* Define NON_BLOCKING_CONNECT if we can support non-blocking connects. */
197 /* Only W32 has this, it really means that select can't take write mask. */
198 #ifdef BROKEN_NON_BLOCKING_CONNECT
199 #undef NON_BLOCKING_CONNECT
200 #define SELECT_CANT_DO_WRITE_MASK
202 #ifndef NON_BLOCKING_CONNECT
204 #if defined (HAVE_GETPEERNAME) || defined (GNU_LINUX)
205 #if defined (O_NONBLOCK) || defined (O_NDELAY)
206 #if defined (EWOULDBLOCK) || defined (EINPROGRESS)
207 #define NON_BLOCKING_CONNECT
208 #endif /* EWOULDBLOCK || EINPROGRESS */
209 #endif /* O_NONBLOCK || O_NDELAY */
210 #endif /* HAVE_GETPEERNAME || GNU_LINUX */
211 #endif /* HAVE_SELECT */
212 #endif /* NON_BLOCKING_CONNECT */
213 #endif /* BROKEN_NON_BLOCKING_CONNECT */
215 /* Define DATAGRAM_SOCKETS if datagrams can be used safely on
216 this system. We need to read full packets, so we need a
217 "non-destructive" select. So we require either native select,
218 or emulation of select using FIONREAD. */
220 #ifndef BROKEN_DATAGRAM_SOCKETS
221 # if defined HAVE_SELECT || defined USABLE_FIONREAD
222 # if defined HAVE_SENDTO && defined HAVE_RECVFROM && defined EMSGSIZE
223 # define DATAGRAM_SOCKETS
228 #if defined HAVE_LOCAL_SOCKETS && defined DATAGRAM_SOCKETS
229 # define HAVE_SEQPACKET
232 #if !defined (ADAPTIVE_READ_BUFFERING) && !defined (NO_ADAPTIVE_READ_BUFFERING)
233 #define ADAPTIVE_READ_BUFFERING
236 #ifdef ADAPTIVE_READ_BUFFERING
237 #define READ_OUTPUT_DELAY_INCREMENT (EMACS_TIME_RESOLUTION / 100)
238 #define READ_OUTPUT_DELAY_MAX (READ_OUTPUT_DELAY_INCREMENT * 5)
239 #define READ_OUTPUT_DELAY_MAX_MAX (READ_OUTPUT_DELAY_INCREMENT * 7)
241 /* Number of processes which have a non-zero read_output_delay,
242 and therefore might be delayed for adaptive read buffering. */
244 static int process_output_delay_count
;
246 /* Non-zero if any process has non-nil read_output_skip. */
248 static int process_output_skip
;
251 #define process_output_delay_count 0
254 static void create_process (Lisp_Object
, char **, Lisp_Object
);
256 static int keyboard_bit_set (SELECT_TYPE
*);
258 static void deactivate_process (Lisp_Object
);
259 static void status_notify (struct Lisp_Process
*);
260 static int read_process_output (Lisp_Object
, int);
261 static void create_pty (Lisp_Object
);
263 /* If we support a window system, turn on the code to poll periodically
264 to detect C-g. It isn't actually used when doing interrupt input. */
265 #if defined (HAVE_WINDOW_SYSTEM) && !defined (USE_ASYNC_EVENTS)
266 #define POLL_FOR_INPUT
269 static Lisp_Object
get_process (register Lisp_Object name
);
270 static void exec_sentinel (Lisp_Object proc
, Lisp_Object reason
);
272 /* Mask of bits indicating the descriptors that we wait for input on. */
274 static SELECT_TYPE input_wait_mask
;
276 /* Mask that excludes keyboard input descriptor(s). */
278 static SELECT_TYPE non_keyboard_wait_mask
;
280 /* Mask that excludes process input descriptor(s). */
282 static SELECT_TYPE non_process_wait_mask
;
284 /* Mask for selecting for write. */
286 static SELECT_TYPE write_mask
;
288 #ifdef NON_BLOCKING_CONNECT
289 /* Mask of bits indicating the descriptors that we wait for connect to
290 complete on. Once they complete, they are removed from this mask
291 and added to the input_wait_mask and non_keyboard_wait_mask. */
293 static SELECT_TYPE connect_wait_mask
;
295 /* Number of bits set in connect_wait_mask. */
296 static int num_pending_connects
;
297 #endif /* NON_BLOCKING_CONNECT */
299 /* The largest descriptor currently in use for a process object. */
300 static int max_process_desc
;
302 /* The largest descriptor currently in use for input. */
303 static int max_input_desc
;
305 /* Indexed by descriptor, gives the process (if any) for that descriptor */
306 static Lisp_Object chan_process
[MAXDESC
];
308 /* Alist of elements (NAME . PROCESS) */
309 static Lisp_Object Vprocess_alist
;
311 /* Buffered-ahead input char from process, indexed by channel.
312 -1 means empty (no char is buffered).
313 Used on sys V where the only way to tell if there is any
314 output from the process is to read at least one char.
315 Always -1 on systems that support FIONREAD. */
317 static int proc_buffered_char
[MAXDESC
];
319 /* Table of `struct coding-system' for each process. */
320 static struct coding_system
*proc_decode_coding_system
[MAXDESC
];
321 static struct coding_system
*proc_encode_coding_system
[MAXDESC
];
323 #ifdef DATAGRAM_SOCKETS
324 /* Table of `partner address' for datagram sockets. */
325 static struct sockaddr_and_len
{
328 } datagram_address
[MAXDESC
];
329 #define DATAGRAM_CHAN_P(chan) (datagram_address[chan].sa != 0)
330 #define DATAGRAM_CONN_P(proc) (PROCESSP (proc) && datagram_address[XPROCESS (proc)->infd].sa != 0)
332 #define DATAGRAM_CHAN_P(chan) (0)
333 #define DATAGRAM_CONN_P(proc) (0)
336 /* Maximum number of bytes to send to a pty without an eof. */
337 static int pty_max_bytes
;
339 /* These setters are used only in this file, so they can be private. */
341 pset_buffer (struct Lisp_Process
*p
, Lisp_Object val
)
346 pset_command (struct Lisp_Process
*p
, Lisp_Object val
)
351 pset_decode_coding_system (struct Lisp_Process
*p
, Lisp_Object val
)
353 p
->decode_coding_system
= val
;
356 pset_decoding_buf (struct Lisp_Process
*p
, Lisp_Object val
)
358 p
->decoding_buf
= val
;
361 pset_encode_coding_system (struct Lisp_Process
*p
, Lisp_Object val
)
363 p
->encode_coding_system
= val
;
366 pset_encoding_buf (struct Lisp_Process
*p
, Lisp_Object val
)
368 p
->encoding_buf
= val
;
371 pset_filter (struct Lisp_Process
*p
, Lisp_Object val
)
376 pset_log (struct Lisp_Process
*p
, Lisp_Object val
)
381 pset_mark (struct Lisp_Process
*p
, Lisp_Object val
)
386 pset_name (struct Lisp_Process
*p
, Lisp_Object val
)
391 pset_plist (struct Lisp_Process
*p
, Lisp_Object val
)
396 pset_sentinel (struct Lisp_Process
*p
, Lisp_Object val
)
401 pset_status (struct Lisp_Process
*p
, Lisp_Object val
)
406 pset_tty_name (struct Lisp_Process
*p
, Lisp_Object val
)
411 pset_type (struct Lisp_Process
*p
, Lisp_Object val
)
416 pset_write_queue (struct Lisp_Process
*p
, Lisp_Object val
)
418 p
->write_queue
= val
;
423 static struct fd_callback_data
429 int condition
; /* mask of the defines above. */
430 } fd_callback_info
[MAXDESC
];
433 /* Add a file descriptor FD to be monitored for when read is possible.
434 When read is possible, call FUNC with argument DATA. */
437 add_read_fd (int fd
, fd_callback func
, void *data
)
439 eassert (fd
< MAXDESC
);
440 add_keyboard_wait_descriptor (fd
);
442 fd_callback_info
[fd
].func
= func
;
443 fd_callback_info
[fd
].data
= data
;
444 fd_callback_info
[fd
].condition
|= FOR_READ
;
447 /* Stop monitoring file descriptor FD for when read is possible. */
450 delete_read_fd (int fd
)
452 eassert (fd
< MAXDESC
);
453 delete_keyboard_wait_descriptor (fd
);
455 fd_callback_info
[fd
].condition
&= ~FOR_READ
;
456 if (fd_callback_info
[fd
].condition
== 0)
458 fd_callback_info
[fd
].func
= 0;
459 fd_callback_info
[fd
].data
= 0;
463 /* Add a file descriptor FD to be monitored for when write is possible.
464 When write is possible, call FUNC with argument DATA. */
467 add_write_fd (int fd
, fd_callback func
, void *data
)
469 eassert (fd
< MAXDESC
);
470 FD_SET (fd
, &write_mask
);
471 if (fd
> max_input_desc
)
474 fd_callback_info
[fd
].func
= func
;
475 fd_callback_info
[fd
].data
= data
;
476 fd_callback_info
[fd
].condition
|= FOR_WRITE
;
479 /* Stop monitoring file descriptor FD for when write is possible. */
482 delete_write_fd (int fd
)
484 int lim
= max_input_desc
;
486 eassert (fd
< MAXDESC
);
487 FD_CLR (fd
, &write_mask
);
488 fd_callback_info
[fd
].condition
&= ~FOR_WRITE
;
489 if (fd_callback_info
[fd
].condition
== 0)
491 fd_callback_info
[fd
].func
= 0;
492 fd_callback_info
[fd
].data
= 0;
494 if (fd
== max_input_desc
)
495 for (fd
= lim
; fd
>= 0; fd
--)
496 if (FD_ISSET (fd
, &input_wait_mask
) || FD_ISSET (fd
, &write_mask
))
506 /* Compute the Lisp form of the process status, p->status, from
507 the numeric status that was returned by `wait'. */
509 static Lisp_Object
status_convert (int);
512 update_status (struct Lisp_Process
*p
)
514 eassert (p
->raw_status_new
);
515 pset_status (p
, status_convert (p
->raw_status
));
516 p
->raw_status_new
= 0;
519 /* Convert a process status word in Unix format to
520 the list that we use internally. */
523 status_convert (int w
)
526 return Fcons (Qstop
, Fcons (make_number (WSTOPSIG (w
)), Qnil
));
527 else if (WIFEXITED (w
))
528 return Fcons (Qexit
, Fcons (make_number (WEXITSTATUS (w
)),
529 WCOREDUMP (w
) ? Qt
: Qnil
));
530 else if (WIFSIGNALED (w
))
531 return Fcons (Qsignal
, Fcons (make_number (WTERMSIG (w
)),
532 WCOREDUMP (w
) ? Qt
: Qnil
));
537 /* Given a status-list, extract the three pieces of information
538 and store them individually through the three pointers. */
541 decode_status (Lisp_Object l
, Lisp_Object
*symbol
, int *code
, int *coredump
)
555 *code
= XFASTINT (XCAR (tem
));
557 *coredump
= !NILP (tem
);
561 /* Return a string describing a process status list. */
564 status_message (struct Lisp_Process
*p
)
566 Lisp_Object status
= p
->status
;
569 Lisp_Object string
, string2
;
571 decode_status (status
, &symbol
, &code
, &coredump
);
573 if (EQ (symbol
, Qsignal
) || EQ (symbol
, Qstop
))
576 synchronize_system_messages_locale ();
577 signame
= strsignal (code
);
579 string
= build_string ("unknown");
584 string
= build_unibyte_string (signame
);
585 if (! NILP (Vlocale_coding_system
))
586 string
= (code_convert_string_norecord
587 (string
, Vlocale_coding_system
, 0));
588 c1
= STRING_CHAR (SDATA (string
));
591 Faset (string
, make_number (0), make_number (c2
));
593 string2
= build_string (coredump
? " (core dumped)\n" : "\n");
594 return concat2 (string
, string2
);
596 else if (EQ (symbol
, Qexit
))
599 return build_string (code
== 0 ? "deleted\n" : "connection broken by remote peer\n");
601 return build_string ("finished\n");
602 string
= Fnumber_to_string (make_number (code
));
603 string2
= build_string (coredump
? " (core dumped)\n" : "\n");
604 return concat3 (build_string ("exited abnormally with code "),
607 else if (EQ (symbol
, Qfailed
))
609 string
= Fnumber_to_string (make_number (code
));
610 string2
= build_string ("\n");
611 return concat3 (build_string ("failed with code "),
615 return Fcopy_sequence (Fsymbol_name (symbol
));
620 /* The file name of the pty opened by allocate_pty. */
621 static char pty_name
[24];
623 /* Open an available pty, returning a file descriptor.
624 Return -1 on failure.
625 The file name of the terminal corresponding to the pty
626 is left in the variable pty_name. */
637 for (c
= FIRST_PTY_LETTER
; c
<= 'z'; c
++)
638 for (i
= 0; i
< 16; i
++)
641 #ifdef PTY_NAME_SPRINTF
644 sprintf (pty_name
, "/dev/pty%c%x", c
, i
);
645 #endif /* no PTY_NAME_SPRINTF */
649 #else /* no PTY_OPEN */
651 { /* Some systems name their pseudoterminals so that there are gaps in
652 the usual sequence - for example, on HP9000/S700 systems, there
653 are no pseudoterminals with names ending in 'f'. So we wait for
654 three failures in a row before deciding that we've reached the
656 int failed_count
= 0;
659 if (stat (pty_name
, &stb
) < 0)
662 if (failed_count
>= 3)
669 fd
= emacs_open (pty_name
, O_RDWR
| O_NONBLOCK
, 0);
671 fd
= emacs_open (pty_name
, O_RDWR
| O_NDELAY
, 0);
674 #endif /* no PTY_OPEN */
678 /* check to make certain that both sides are available
679 this avoids a nasty yet stupid bug in rlogins */
680 #ifdef PTY_TTY_NAME_SPRINTF
683 sprintf (pty_name
, "/dev/tty%c%x", c
, i
);
684 #endif /* no PTY_TTY_NAME_SPRINTF */
685 if (access (pty_name
, 6) != 0)
700 #endif /* HAVE_PTYS */
703 make_process (Lisp_Object name
)
705 register Lisp_Object val
, tem
, name1
;
706 register struct Lisp_Process
*p
;
707 char suffix
[sizeof "<>" + INT_STRLEN_BOUND (printmax_t
)];
710 p
= allocate_process ();
711 /* Initialize Lisp data. Note that allocate_process initializes all
712 Lisp data to nil, so do it only for slots which should not be nil. */
713 pset_status (p
, Qrun
);
714 pset_mark (p
, Fmake_marker ());
716 /* Initialize non-Lisp data. Note that allocate_process zeroes out all
717 non-Lisp data, so do it only for slots which should not be zero. */
722 p
->gnutls_initstage
= GNUTLS_STAGE_EMPTY
;
725 /* If name is already in use, modify it until it is unused. */
730 tem
= Fget_process (name1
);
731 if (NILP (tem
)) break;
732 name1
= concat2 (name
, make_formatted_string (suffix
, "<%"pMd
">", i
));
736 XSETPROCESS (val
, p
);
737 Vprocess_alist
= Fcons (Fcons (name
, val
), Vprocess_alist
);
742 remove_process (register Lisp_Object proc
)
744 register Lisp_Object pair
;
746 pair
= Frassq (proc
, Vprocess_alist
);
747 Vprocess_alist
= Fdelq (pair
, Vprocess_alist
);
749 deactivate_process (proc
);
753 DEFUN ("processp", Fprocessp
, Sprocessp
, 1, 1, 0,
754 doc
: /* Return t if OBJECT is a process. */)
757 return PROCESSP (object
) ? Qt
: Qnil
;
760 DEFUN ("get-process", Fget_process
, Sget_process
, 1, 1, 0,
761 doc
: /* Return the process named NAME, or nil if there is none. */)
762 (register Lisp_Object name
)
767 return Fcdr (Fassoc (name
, Vprocess_alist
));
770 /* This is how commands for the user decode process arguments. It
771 accepts a process, a process name, a buffer, a buffer name, or nil.
772 Buffers denote the first process in the buffer, and nil denotes the
776 get_process (register Lisp_Object name
)
778 register Lisp_Object proc
, obj
;
781 obj
= Fget_process (name
);
783 obj
= Fget_buffer (name
);
785 error ("Process %s does not exist", SDATA (name
));
787 else if (NILP (name
))
788 obj
= Fcurrent_buffer ();
792 /* Now obj should be either a buffer object or a process object.
796 proc
= Fget_buffer_process (obj
);
798 error ("Buffer %s has no process", SDATA (BVAR (XBUFFER (obj
), name
)));
810 /* Fdelete_process promises to immediately forget about the process, but in
811 reality, Emacs needs to remember those processes until they have been
812 treated by the SIGCHLD handler; otherwise this handler would consider the
813 process as being synchronous and say that the synchronous process is
815 static Lisp_Object deleted_pid_list
;
818 DEFUN ("delete-process", Fdelete_process
, Sdelete_process
, 1, 1, 0,
819 doc
: /* Delete PROCESS: kill it and forget about it immediately.
820 PROCESS may be a process, a buffer, the name of a process or buffer, or
821 nil, indicating the current buffer's process. */)
822 (register Lisp_Object process
)
824 register struct Lisp_Process
*p
;
826 process
= get_process (process
);
827 p
= XPROCESS (process
);
829 p
->raw_status_new
= 0;
830 if (NETCONN1_P (p
) || SERIALCONN1_P (p
))
832 pset_status (p
, Fcons (Qexit
, Fcons (make_number (0), Qnil
)));
833 p
->tick
= ++process_tick
;
835 redisplay_preserve_echo_area (13);
837 else if (p
->infd
>= 0)
843 /* No problem storing the pid here, as it is still in Vprocess_alist. */
844 deleted_pid_list
= Fcons (make_fixnum_or_float (pid
),
845 /* GC treated elements set to nil. */
846 Fdelq (Qnil
, deleted_pid_list
));
847 /* If the process has already signaled, remove it from the list. */
848 if (p
->raw_status_new
)
851 if (CONSP (p
->status
))
852 symbol
= XCAR (p
->status
);
853 if (EQ (symbol
, Qsignal
) || EQ (symbol
, Qexit
))
855 = Fdelete (make_fixnum_or_float (pid
), deleted_pid_list
);
859 Fkill_process (process
, Qnil
);
860 /* Do this now, since remove_process will make the
861 SIGCHLD handler do nothing. */
862 pset_status (p
, Fcons (Qsignal
, Fcons (make_number (SIGKILL
), Qnil
)));
863 p
->tick
= ++process_tick
;
865 redisplay_preserve_echo_area (13);
868 remove_process (process
);
872 DEFUN ("process-status", Fprocess_status
, Sprocess_status
, 1, 1, 0,
873 doc
: /* Return the status of PROCESS.
874 The returned value is one of the following symbols:
875 run -- for a process that is running.
876 stop -- for a process stopped but continuable.
877 exit -- for a process that has exited.
878 signal -- for a process that has got a fatal signal.
879 open -- for a network stream connection that is open.
880 listen -- for a network stream server that is listening.
881 closed -- for a network stream connection that is closed.
882 connect -- when waiting for a non-blocking connection to complete.
883 failed -- when a non-blocking connection has failed.
884 nil -- if arg is a process name and no such process exists.
885 PROCESS may be a process, a buffer, the name of a process, or
886 nil, indicating the current buffer's process. */)
887 (register Lisp_Object process
)
889 register struct Lisp_Process
*p
;
890 register Lisp_Object status
;
892 if (STRINGP (process
))
893 process
= Fget_process (process
);
895 process
= get_process (process
);
900 p
= XPROCESS (process
);
901 if (p
->raw_status_new
)
905 status
= XCAR (status
);
906 if (NETCONN1_P (p
) || SERIALCONN1_P (p
))
908 if (EQ (status
, Qexit
))
910 else if (EQ (p
->command
, Qt
))
912 else if (EQ (status
, Qrun
))
918 DEFUN ("process-exit-status", Fprocess_exit_status
, Sprocess_exit_status
,
920 doc
: /* Return the exit status of PROCESS or the signal number that killed it.
921 If PROCESS has not yet exited or died, return 0. */)
922 (register Lisp_Object process
)
924 CHECK_PROCESS (process
);
925 if (XPROCESS (process
)->raw_status_new
)
926 update_status (XPROCESS (process
));
927 if (CONSP (XPROCESS (process
)->status
))
928 return XCAR (XCDR (XPROCESS (process
)->status
));
929 return make_number (0);
932 DEFUN ("process-id", Fprocess_id
, Sprocess_id
, 1, 1, 0,
933 doc
: /* Return the process id of PROCESS.
934 This is the pid of the external process which PROCESS uses or talks to.
935 For a network connection, this value is nil. */)
936 (register Lisp_Object process
)
940 CHECK_PROCESS (process
);
941 pid
= XPROCESS (process
)->pid
;
942 return (pid
? make_fixnum_or_float (pid
) : Qnil
);
945 DEFUN ("process-name", Fprocess_name
, Sprocess_name
, 1, 1, 0,
946 doc
: /* Return the name of PROCESS, as a string.
947 This is the name of the program invoked in PROCESS,
948 possibly modified to make it unique among process names. */)
949 (register Lisp_Object process
)
951 CHECK_PROCESS (process
);
952 return XPROCESS (process
)->name
;
955 DEFUN ("process-command", Fprocess_command
, Sprocess_command
, 1, 1, 0,
956 doc
: /* Return the command that was executed to start PROCESS.
957 This is a list of strings, the first string being the program executed
958 and the rest of the strings being the arguments given to it.
959 For a network or serial process, this is nil (process is running) or t
960 \(process is stopped). */)
961 (register Lisp_Object process
)
963 CHECK_PROCESS (process
);
964 return XPROCESS (process
)->command
;
967 DEFUN ("process-tty-name", Fprocess_tty_name
, Sprocess_tty_name
, 1, 1, 0,
968 doc
: /* Return the name of the terminal PROCESS uses, or nil if none.
969 This is the terminal that the process itself reads and writes on,
970 not the name of the pty that Emacs uses to talk with that terminal. */)
971 (register Lisp_Object process
)
973 CHECK_PROCESS (process
);
974 return XPROCESS (process
)->tty_name
;
977 DEFUN ("set-process-buffer", Fset_process_buffer
, Sset_process_buffer
,
979 doc
: /* Set buffer associated with PROCESS to BUFFER (a buffer, or nil).
981 (register Lisp_Object process
, Lisp_Object buffer
)
983 struct Lisp_Process
*p
;
985 CHECK_PROCESS (process
);
987 CHECK_BUFFER (buffer
);
988 p
= XPROCESS (process
);
989 pset_buffer (p
, buffer
);
990 if (NETCONN1_P (p
) || SERIALCONN1_P (p
))
991 pset_childp (p
, Fplist_put (p
->childp
, QCbuffer
, buffer
));
992 setup_process_coding_systems (process
);
996 DEFUN ("process-buffer", Fprocess_buffer
, Sprocess_buffer
,
998 doc
: /* Return the buffer PROCESS is associated with.
999 Output from PROCESS is inserted in this buffer unless PROCESS has a filter. */)
1000 (register Lisp_Object process
)
1002 CHECK_PROCESS (process
);
1003 return XPROCESS (process
)->buffer
;
1006 DEFUN ("process-mark", Fprocess_mark
, Sprocess_mark
,
1008 doc
: /* Return the marker for the end of the last output from PROCESS. */)
1009 (register Lisp_Object process
)
1011 CHECK_PROCESS (process
);
1012 return XPROCESS (process
)->mark
;
1015 DEFUN ("set-process-filter", Fset_process_filter
, Sset_process_filter
,
1017 doc
: /* Give PROCESS the filter function FILTER; nil means no filter.
1018 A value of t means stop accepting output from the process.
1020 When a process has a filter, its buffer is not used for output.
1021 Instead, each time it does output, the entire string of output is
1022 passed to the filter.
1024 The filter gets two arguments: the process and the string of output.
1025 The string argument is normally a multibyte string, except:
1026 - if the process' input coding system is no-conversion or raw-text,
1027 it is a unibyte string (the non-converted input), or else
1028 - if `default-enable-multibyte-characters' is nil, it is a unibyte
1029 string (the result of converting the decoded input multibyte
1030 string to unibyte with `string-make-unibyte'). */)
1031 (register Lisp_Object process
, Lisp_Object filter
)
1033 struct Lisp_Process
*p
;
1035 CHECK_PROCESS (process
);
1036 p
= XPROCESS (process
);
1038 /* Don't signal an error if the process' input file descriptor
1039 is closed. This could make debugging Lisp more difficult,
1040 for example when doing something like
1042 (setq process (start-process ...))
1044 (set-process-filter process ...) */
1048 if (EQ (filter
, Qt
) && !EQ (p
->status
, Qlisten
))
1050 FD_CLR (p
->infd
, &input_wait_mask
);
1051 FD_CLR (p
->infd
, &non_keyboard_wait_mask
);
1053 else if (EQ (p
->filter
, Qt
)
1054 /* Network or serial process not stopped: */
1055 && !EQ (p
->command
, Qt
))
1057 FD_SET (p
->infd
, &input_wait_mask
);
1058 FD_SET (p
->infd
, &non_keyboard_wait_mask
);
1062 pset_filter (p
, filter
);
1063 if (NETCONN1_P (p
) || SERIALCONN1_P (p
))
1064 pset_childp (p
, Fplist_put (p
->childp
, QCfilter
, filter
));
1065 setup_process_coding_systems (process
);
1069 DEFUN ("process-filter", Fprocess_filter
, Sprocess_filter
,
1071 doc
: /* Returns the filter function of PROCESS; nil if none.
1072 See `set-process-filter' for more info on filter functions. */)
1073 (register Lisp_Object process
)
1075 CHECK_PROCESS (process
);
1076 return XPROCESS (process
)->filter
;
1079 DEFUN ("set-process-sentinel", Fset_process_sentinel
, Sset_process_sentinel
,
1081 doc
: /* Give PROCESS the sentinel SENTINEL; nil for none.
1082 The sentinel is called as a function when the process changes state.
1083 It gets two arguments: the process, and a string describing the change. */)
1084 (register Lisp_Object process
, Lisp_Object sentinel
)
1086 struct Lisp_Process
*p
;
1088 CHECK_PROCESS (process
);
1089 p
= XPROCESS (process
);
1091 pset_sentinel (p
, sentinel
);
1092 if (NETCONN1_P (p
) || SERIALCONN1_P (p
))
1093 pset_childp (p
, Fplist_put (p
->childp
, QCsentinel
, sentinel
));
1097 DEFUN ("process-sentinel", Fprocess_sentinel
, Sprocess_sentinel
,
1099 doc
: /* Return the sentinel of PROCESS; nil if none.
1100 See `set-process-sentinel' for more info on sentinels. */)
1101 (register Lisp_Object process
)
1103 CHECK_PROCESS (process
);
1104 return XPROCESS (process
)->sentinel
;
1107 DEFUN ("set-process-window-size", Fset_process_window_size
,
1108 Sset_process_window_size
, 3, 3, 0,
1109 doc
: /* Tell PROCESS that it has logical window size HEIGHT and WIDTH. */)
1110 (register Lisp_Object process
, Lisp_Object height
, Lisp_Object width
)
1112 CHECK_PROCESS (process
);
1113 CHECK_RANGED_INTEGER (height
, 0, INT_MAX
);
1114 CHECK_RANGED_INTEGER (width
, 0, INT_MAX
);
1116 if (XPROCESS (process
)->infd
< 0
1117 || set_window_size (XPROCESS (process
)->infd
,
1118 XINT (height
), XINT (width
)) <= 0)
1124 DEFUN ("set-process-inherit-coding-system-flag",
1125 Fset_process_inherit_coding_system_flag
,
1126 Sset_process_inherit_coding_system_flag
, 2, 2, 0,
1127 doc
: /* Determine whether buffer of PROCESS will inherit coding-system.
1128 If the second argument FLAG is non-nil, then the variable
1129 `buffer-file-coding-system' of the buffer associated with PROCESS
1130 will be bound to the value of the coding system used to decode
1133 This is useful when the coding system specified for the process buffer
1134 leaves either the character code conversion or the end-of-line conversion
1135 unspecified, or if the coding system used to decode the process output
1136 is more appropriate for saving the process buffer.
1138 Binding the variable `inherit-process-coding-system' to non-nil before
1139 starting the process is an alternative way of setting the inherit flag
1140 for the process which will run.
1142 This function returns FLAG. */)
1143 (register Lisp_Object process
, Lisp_Object flag
)
1145 CHECK_PROCESS (process
);
1146 XPROCESS (process
)->inherit_coding_system_flag
= !NILP (flag
);
1150 DEFUN ("set-process-query-on-exit-flag",
1151 Fset_process_query_on_exit_flag
, Sset_process_query_on_exit_flag
,
1153 doc
: /* Specify if query is needed for PROCESS when Emacs is exited.
1154 If the second argument FLAG is non-nil, Emacs will query the user before
1155 exiting or killing a buffer if PROCESS is running. This function
1157 (register Lisp_Object process
, Lisp_Object flag
)
1159 CHECK_PROCESS (process
);
1160 XPROCESS (process
)->kill_without_query
= NILP (flag
);
1164 DEFUN ("process-query-on-exit-flag",
1165 Fprocess_query_on_exit_flag
, Sprocess_query_on_exit_flag
,
1167 doc
: /* Return the current value of query-on-exit flag for PROCESS. */)
1168 (register Lisp_Object process
)
1170 CHECK_PROCESS (process
);
1171 return (XPROCESS (process
)->kill_without_query
? Qnil
: Qt
);
1174 DEFUN ("process-contact", Fprocess_contact
, Sprocess_contact
,
1176 doc
: /* Return the contact info of PROCESS; t for a real child.
1177 For a network or serial connection, the value depends on the optional
1178 KEY arg. If KEY is nil, value is a cons cell of the form (HOST
1179 SERVICE) for a network connection or (PORT SPEED) for a serial
1180 connection. If KEY is t, the complete contact information for the
1181 connection is returned, else the specific value for the keyword KEY is
1182 returned. See `make-network-process' or `make-serial-process' for a
1183 list of keywords. */)
1184 (register Lisp_Object process
, Lisp_Object key
)
1186 Lisp_Object contact
;
1188 CHECK_PROCESS (process
);
1189 contact
= XPROCESS (process
)->childp
;
1191 #ifdef DATAGRAM_SOCKETS
1192 if (DATAGRAM_CONN_P (process
)
1193 && (EQ (key
, Qt
) || EQ (key
, QCremote
)))
1194 contact
= Fplist_put (contact
, QCremote
,
1195 Fprocess_datagram_address (process
));
1198 if ((!NETCONN_P (process
) && !SERIALCONN_P (process
)) || EQ (key
, Qt
))
1200 if (NILP (key
) && NETCONN_P (process
))
1201 return Fcons (Fplist_get (contact
, QChost
),
1202 Fcons (Fplist_get (contact
, QCservice
), Qnil
));
1203 if (NILP (key
) && SERIALCONN_P (process
))
1204 return Fcons (Fplist_get (contact
, QCport
),
1205 Fcons (Fplist_get (contact
, QCspeed
), Qnil
));
1206 return Fplist_get (contact
, key
);
1209 DEFUN ("process-plist", Fprocess_plist
, Sprocess_plist
,
1211 doc
: /* Return the plist of PROCESS. */)
1212 (register Lisp_Object process
)
1214 CHECK_PROCESS (process
);
1215 return XPROCESS (process
)->plist
;
1218 DEFUN ("set-process-plist", Fset_process_plist
, Sset_process_plist
,
1220 doc
: /* Replace the plist of PROCESS with PLIST. Returns PLIST. */)
1221 (register Lisp_Object process
, Lisp_Object plist
)
1223 CHECK_PROCESS (process
);
1226 pset_plist (XPROCESS (process
), plist
);
1230 #if 0 /* Turned off because we don't currently record this info
1231 in the process. Perhaps add it. */
1232 DEFUN ("process-connection", Fprocess_connection
, Sprocess_connection
, 1, 1, 0,
1233 doc
: /* Return the connection type of PROCESS.
1234 The value is nil for a pipe, t or `pty' for a pty, or `stream' for
1235 a socket connection. */)
1236 (Lisp_Object process
)
1238 return XPROCESS (process
)->type
;
1242 DEFUN ("process-type", Fprocess_type
, Sprocess_type
, 1, 1, 0,
1243 doc
: /* Return the connection type of PROCESS.
1244 The value is either the symbol `real', `network', or `serial'.
1245 PROCESS may be a process, a buffer, the name of a process or buffer, or
1246 nil, indicating the current buffer's process. */)
1247 (Lisp_Object process
)
1250 proc
= get_process (process
);
1251 return XPROCESS (proc
)->type
;
1254 DEFUN ("format-network-address", Fformat_network_address
, Sformat_network_address
,
1256 doc
: /* Convert network ADDRESS from internal format to a string.
1257 A 4 or 5 element vector represents an IPv4 address (with port number).
1258 An 8 or 9 element vector represents an IPv6 address (with port number).
1259 If optional second argument OMIT-PORT is non-nil, don't include a port
1260 number in the string, even when present in ADDRESS.
1261 Returns nil if format of ADDRESS is invalid. */)
1262 (Lisp_Object address
, Lisp_Object omit_port
)
1267 if (STRINGP (address
)) /* AF_LOCAL */
1270 if (VECTORP (address
)) /* AF_INET or AF_INET6 */
1272 register struct Lisp_Vector
*p
= XVECTOR (address
);
1273 ptrdiff_t size
= p
->header
.size
;
1274 Lisp_Object args
[10];
1277 if (size
== 4 || (size
== 5 && !NILP (omit_port
)))
1279 args
[0] = build_string ("%d.%d.%d.%d");
1284 args
[0] = build_string ("%d.%d.%d.%d:%d");
1287 else if (size
== 8 || (size
== 9 && !NILP (omit_port
)))
1289 args
[0] = build_string ("%x:%x:%x:%x:%x:%x:%x:%x");
1294 args
[0] = build_string ("[%x:%x:%x:%x:%x:%x:%x:%x]:%d");
1300 for (i
= 0; i
< nargs
; i
++)
1302 if (! RANGED_INTEGERP (0, p
->contents
[i
], 65535))
1305 if (nargs
<= 5 /* IPv4 */
1306 && i
< 4 /* host, not port */
1307 && XINT (p
->contents
[i
]) > 255)
1310 args
[i
+1] = p
->contents
[i
];
1313 return Fformat (nargs
+1, args
);
1316 if (CONSP (address
))
1318 Lisp_Object args
[2];
1319 args
[0] = build_string ("<Family %d>");
1320 args
[1] = Fcar (address
);
1321 return Fformat (2, args
);
1327 DEFUN ("process-list", Fprocess_list
, Sprocess_list
, 0, 0, 0,
1328 doc
: /* Return a list of all processes. */)
1331 return Fmapcar (Qcdr
, Vprocess_alist
);
1334 /* Starting asynchronous inferior processes. */
1336 static Lisp_Object
start_process_unwind (Lisp_Object proc
);
1338 DEFUN ("start-process", Fstart_process
, Sstart_process
, 3, MANY
, 0,
1339 doc
: /* Start a program in a subprocess. Return the process object for it.
1340 NAME is name for process. It is modified if necessary to make it unique.
1341 BUFFER is the buffer (or buffer name) to associate with the process.
1343 Process output (both standard output and standard error streams) goes
1344 at end of BUFFER, unless you specify an output stream or filter
1345 function to handle the output. BUFFER may also be nil, meaning that
1346 this process is not associated with any buffer.
1348 PROGRAM is the program file name. It is searched for in `exec-path'
1349 (which see). If nil, just associate a pty with the buffer. Remaining
1350 arguments are strings to give program as arguments.
1352 If you want to separate standard output from standard error, invoke
1353 the command through a shell and redirect one of them using the shell
1356 usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS) */)
1357 (ptrdiff_t nargs
, Lisp_Object
*args
)
1359 Lisp_Object buffer
, name
, program
, proc
, current_dir
, tem
;
1360 register unsigned char **new_argv
;
1362 ptrdiff_t count
= SPECPDL_INDEX ();
1366 buffer
= Fget_buffer_create (buffer
);
1368 /* Make sure that the child will be able to chdir to the current
1369 buffer's current directory, or its unhandled equivalent. We
1370 can't just have the child check for an error when it does the
1371 chdir, since it's in a vfork.
1373 We have to GCPRO around this because Fexpand_file_name and
1374 Funhandled_file_name_directory might call a file name handling
1375 function. The argument list is protected by the caller, so all
1376 we really have to worry about is buffer. */
1378 struct gcpro gcpro1
, gcpro2
;
1380 current_dir
= BVAR (current_buffer
, directory
);
1382 GCPRO2 (buffer
, current_dir
);
1384 current_dir
= Funhandled_file_name_directory (current_dir
);
1385 if (NILP (current_dir
))
1386 /* If the file name handler says that current_dir is unreachable, use
1387 a sensible default. */
1388 current_dir
= build_string ("~/");
1389 current_dir
= expand_and_dir_to_file (current_dir
, Qnil
);
1390 if (NILP (Ffile_accessible_directory_p (current_dir
)))
1391 report_file_error ("Setting current directory",
1392 Fcons (BVAR (current_buffer
, directory
), Qnil
));
1398 CHECK_STRING (name
);
1402 if (!NILP (program
))
1403 CHECK_STRING (program
);
1405 proc
= make_process (name
);
1406 /* If an error occurs and we can't start the process, we want to
1407 remove it from the process list. This means that each error
1408 check in create_process doesn't need to call remove_process
1409 itself; it's all taken care of here. */
1410 record_unwind_protect (start_process_unwind
, proc
);
1412 pset_childp (XPROCESS (proc
), Qt
);
1413 pset_plist (XPROCESS (proc
), Qnil
);
1414 pset_type (XPROCESS (proc
), Qreal
);
1415 pset_buffer (XPROCESS (proc
), buffer
);
1416 pset_sentinel (XPROCESS (proc
), Qnil
);
1417 pset_filter (XPROCESS (proc
), Qnil
);
1418 pset_command (XPROCESS (proc
), Flist (nargs
- 2, args
+ 2));
1421 /* AKA GNUTLS_INITSTAGE(proc). */
1422 XPROCESS (proc
)->gnutls_initstage
= GNUTLS_STAGE_EMPTY
;
1423 pset_gnutls_cred_type (XPROCESS (proc
), Qnil
);
1426 #ifdef ADAPTIVE_READ_BUFFERING
1427 XPROCESS (proc
)->adaptive_read_buffering
1428 = (NILP (Vprocess_adaptive_read_buffering
) ? 0
1429 : EQ (Vprocess_adaptive_read_buffering
, Qt
) ? 1 : 2);
1432 /* Make the process marker point into the process buffer (if any). */
1433 if (BUFFERP (buffer
))
1434 set_marker_both (XPROCESS (proc
)->mark
, buffer
,
1435 BUF_ZV (XBUFFER (buffer
)),
1436 BUF_ZV_BYTE (XBUFFER (buffer
)));
1439 /* Decide coding systems for communicating with the process. Here
1440 we don't setup the structure coding_system nor pay attention to
1441 unibyte mode. They are done in create_process. */
1443 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
1444 Lisp_Object coding_systems
= Qt
;
1445 Lisp_Object val
, *args2
;
1446 struct gcpro gcpro1
, gcpro2
;
1448 val
= Vcoding_system_for_read
;
1451 args2
= alloca ((nargs
+ 1) * sizeof *args2
);
1452 args2
[0] = Qstart_process
;
1453 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
1454 GCPRO2 (proc
, current_dir
);
1455 if (!NILP (program
))
1456 coding_systems
= Ffind_operation_coding_system (nargs
+ 1, args2
);
1458 if (CONSP (coding_systems
))
1459 val
= XCAR (coding_systems
);
1460 else if (CONSP (Vdefault_process_coding_system
))
1461 val
= XCAR (Vdefault_process_coding_system
);
1463 pset_decode_coding_system (XPROCESS (proc
), val
);
1465 val
= Vcoding_system_for_write
;
1468 if (EQ (coding_systems
, Qt
))
1470 args2
= alloca ((nargs
+ 1) * sizeof *args2
);
1471 args2
[0] = Qstart_process
;
1472 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
1473 GCPRO2 (proc
, current_dir
);
1474 if (!NILP (program
))
1475 coding_systems
= Ffind_operation_coding_system (nargs
+ 1, args2
);
1478 if (CONSP (coding_systems
))
1479 val
= XCDR (coding_systems
);
1480 else if (CONSP (Vdefault_process_coding_system
))
1481 val
= XCDR (Vdefault_process_coding_system
);
1483 pset_encode_coding_system (XPROCESS (proc
), val
);
1484 /* Note: At this moment, the above coding system may leave
1485 text-conversion or eol-conversion unspecified. They will be
1486 decided after we read output from the process and decode it by
1487 some coding system, or just before we actually send a text to
1492 pset_decoding_buf (XPROCESS (proc
), empty_unibyte_string
);
1493 XPROCESS (proc
)->decoding_carryover
= 0;
1494 pset_encoding_buf (XPROCESS (proc
), empty_unibyte_string
);
1496 XPROCESS (proc
)->inherit_coding_system_flag
1497 = !(NILP (buffer
) || !inherit_process_coding_system
);
1499 if (!NILP (program
))
1501 /* If program file name is not absolute, search our path for it.
1502 Put the name we will really use in TEM. */
1503 if (!IS_DIRECTORY_SEP (SREF (program
, 0))
1504 && !(SCHARS (program
) > 1
1505 && IS_DEVICE_SEP (SREF (program
, 1))))
1507 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1510 GCPRO4 (name
, program
, buffer
, current_dir
);
1511 openp (Vexec_path
, program
, Vexec_suffixes
, &tem
, make_number (X_OK
));
1514 report_file_error ("Searching for program", Fcons (program
, Qnil
));
1515 tem
= Fexpand_file_name (tem
, Qnil
);
1519 if (!NILP (Ffile_directory_p (program
)))
1520 error ("Specified program for new process is a directory");
1524 /* If program file name starts with /: for quoting a magic name,
1526 if (SBYTES (tem
) > 2 && SREF (tem
, 0) == '/'
1527 && SREF (tem
, 1) == ':')
1528 tem
= Fsubstring (tem
, make_number (2), Qnil
);
1531 Lisp_Object arg_encoding
= Qnil
;
1532 struct gcpro gcpro1
;
1535 /* Encode the file name and put it in NEW_ARGV.
1536 That's where the child will use it to execute the program. */
1537 tem
= Fcons (ENCODE_FILE (tem
), Qnil
);
1539 /* Here we encode arguments by the coding system used for sending
1540 data to the process. We don't support using different coding
1541 systems for encoding arguments and for encoding data sent to the
1544 for (i
= 3; i
< nargs
; i
++)
1546 tem
= Fcons (args
[i
], tem
);
1547 CHECK_STRING (XCAR (tem
));
1548 if (STRING_MULTIBYTE (XCAR (tem
)))
1550 if (NILP (arg_encoding
))
1551 arg_encoding
= (complement_process_encoding_system
1552 (XPROCESS (proc
)->encode_coding_system
));
1554 code_convert_string_norecord
1555 (XCAR (tem
), arg_encoding
, 1));
1562 /* Now that everything is encoded we can collect the strings into
1564 new_argv
= alloca ((nargs
- 1) * sizeof *new_argv
);
1565 new_argv
[nargs
- 2] = 0;
1567 for (i
= nargs
- 2; i
-- != 0; )
1569 new_argv
[i
] = SDATA (XCAR (tem
));
1573 create_process (proc
, (char **) new_argv
, current_dir
);
1578 return unbind_to (count
, proc
);
1581 /* This function is the unwind_protect form for Fstart_process. If
1582 PROC doesn't have its pid set, then we know someone has signaled
1583 an error and the process wasn't started successfully, so we should
1584 remove it from the process list. */
1586 start_process_unwind (Lisp_Object proc
)
1588 if (!PROCESSP (proc
))
1591 /* Was PROC started successfully?
1592 -2 is used for a pty with no process, eg for gdb. */
1593 if (XPROCESS (proc
)->pid
<= 0 && XPROCESS (proc
)->pid
!= -2)
1594 remove_process (proc
);
1600 create_process_1 (struct atimer
*timer
)
1602 /* Nothing to do. */
1607 create_process (Lisp_Object process
, char **new_argv
, Lisp_Object current_dir
)
1609 int inchannel
, outchannel
;
1612 #if !defined (WINDOWSNT) && defined (FD_CLOEXEC)
1613 int wait_child_setup
[2];
1615 sigset_t blocked
, procmask
;
1616 struct sigaction sigint_action
;
1617 struct sigaction sigquit_action
;
1618 struct sigaction sigpipe_action
;
1620 struct sigaction sighup_action
;
1622 /* Use volatile to protect variables from being clobbered by longjmp. */
1623 volatile int forkin
, forkout
;
1624 volatile int pty_flag
= 0;
1626 inchannel
= outchannel
= -1;
1629 if (!NILP (Vprocess_connection_type
))
1630 outchannel
= inchannel
= allocate_pty ();
1634 #if ! defined (USG) || defined (USG_SUBTTY_WORKS)
1635 /* On most USG systems it does not work to open the pty's tty here,
1636 then close it and reopen it in the child. */
1638 /* Don't let this terminal become our controlling terminal
1639 (in case we don't have one). */
1640 forkout
= forkin
= emacs_open (pty_name
, O_RDWR
| O_NOCTTY
, 0);
1642 forkout
= forkin
= emacs_open (pty_name
, O_RDWR
, 0);
1645 report_file_error ("Opening pty", Qnil
);
1647 forkin
= forkout
= -1;
1648 #endif /* not USG, or USG_SUBTTY_WORKS */
1652 #endif /* HAVE_PTYS */
1657 report_file_error ("Creating pipe", Qnil
);
1663 emacs_close (inchannel
);
1664 emacs_close (forkout
);
1665 report_file_error ("Creating pipe", Qnil
);
1671 #if !defined (WINDOWSNT) && defined (FD_CLOEXEC)
1675 tem
= pipe (wait_child_setup
);
1677 report_file_error ("Creating pipe", Qnil
);
1678 tem
= fcntl (wait_child_setup
[1], F_GETFD
, 0);
1680 tem
= fcntl (wait_child_setup
[1], F_SETFD
, tem
| FD_CLOEXEC
);
1683 emacs_close (wait_child_setup
[0]);
1684 emacs_close (wait_child_setup
[1]);
1685 report_file_error ("Setting file descriptor flags", Qnil
);
1691 fcntl (inchannel
, F_SETFL
, O_NONBLOCK
);
1692 fcntl (outchannel
, F_SETFL
, O_NONBLOCK
);
1695 fcntl (inchannel
, F_SETFL
, O_NDELAY
);
1696 fcntl (outchannel
, F_SETFL
, O_NDELAY
);
1700 /* Record this as an active process, with its channels.
1701 As a result, child_setup will close Emacs's side of the pipes. */
1702 chan_process
[inchannel
] = process
;
1703 XPROCESS (process
)->infd
= inchannel
;
1704 XPROCESS (process
)->outfd
= outchannel
;
1706 /* Previously we recorded the tty descriptor used in the subprocess.
1707 It was only used for getting the foreground tty process, so now
1708 we just reopen the device (see emacs_get_tty_pgrp) as this is
1709 more portable (see USG_SUBTTY_WORKS above). */
1711 XPROCESS (process
)->pty_flag
= pty_flag
;
1712 pset_status (XPROCESS (process
), Qrun
);
1714 /* Delay interrupts until we have a chance to store
1715 the new fork's pid in its process structure */
1716 sigemptyset (&blocked
);
1718 sigaddset (&blocked
, SIGCHLD
);
1720 #ifdef HAVE_WORKING_VFORK
1721 /* On many hosts (e.g. Solaris 2.4), if a vforked child calls `signal',
1722 this sets the parent's signal handlers as well as the child's.
1723 So delay all interrupts whose handlers the child might munge,
1724 and record the current handlers so they can be restored later. */
1725 sigaddset (&blocked
, SIGINT
); sigaction (SIGINT
, 0, &sigint_action
);
1726 sigaddset (&blocked
, SIGQUIT
); sigaction (SIGQUIT
, 0, &sigquit_action
);
1727 sigaddset (&blocked
, SIGPIPE
); sigaction (SIGPIPE
, 0, &sigpipe_action
);
1729 sigaddset (&blocked
, SIGHUP
); sigaction (SIGHUP
, 0, &sighup_action
);
1731 #endif /* HAVE_WORKING_VFORK */
1732 pthread_sigmask (SIG_BLOCK
, &blocked
, &procmask
);
1734 FD_SET (inchannel
, &input_wait_mask
);
1735 FD_SET (inchannel
, &non_keyboard_wait_mask
);
1736 if (inchannel
> max_process_desc
)
1737 max_process_desc
= inchannel
;
1739 /* Until we store the proper pid, enable the SIGCHLD handler
1740 to recognize an unknown pid as standing for this process.
1741 It is very important not to let this `marker' value stay
1742 in the table after this function has returned; if it does
1743 it might cause call-process to hang and subsequent asynchronous
1744 processes to get their return values scrambled. */
1745 XPROCESS (process
)->pid
= -1;
1747 /* This must be called after the above line because it may signal an
1749 setup_process_coding_systems (process
);
1754 /* child_setup must clobber environ on systems with true vfork.
1755 Protect it from permanent change. */
1756 char **save_environ
= environ
;
1757 volatile Lisp_Object encoded_current_dir
= ENCODE_FILE (current_dir
);
1762 #endif /* not WINDOWSNT */
1764 int xforkin
= forkin
;
1765 int xforkout
= forkout
;
1767 /* Make the pty be the controlling terminal of the process. */
1769 /* First, disconnect its current controlling terminal. */
1771 /* We tried doing setsid only if pty_flag, but it caused
1772 process_set_signal to fail on SGI when using a pipe. */
1774 /* Make the pty's terminal the controlling terminal. */
1775 if (pty_flag
&& xforkin
>= 0)
1778 /* We ignore the return value
1779 because faith@cs.unc.edu says that is necessary on Linux. */
1780 ioctl (xforkin
, TIOCSCTTY
, 0);
1783 #else /* not HAVE_SETSID */
1785 /* It's very important to call setpgrp here and no time
1786 afterwards. Otherwise, we lose our controlling tty which
1787 is set when we open the pty. */
1790 #endif /* not HAVE_SETSID */
1791 #if defined (LDISC1)
1792 if (pty_flag
&& xforkin
>= 0)
1795 tcgetattr (xforkin
, &t
);
1797 if (tcsetattr (xforkin
, TCSANOW
, &t
) < 0)
1798 emacs_write (1, "create_process/tcsetattr LDISC1 failed\n", 39);
1801 #if defined (NTTYDISC) && defined (TIOCSETD)
1802 if (pty_flag
&& xforkin
>= 0)
1804 /* Use new line discipline. */
1805 int ldisc
= NTTYDISC
;
1806 ioctl (xforkin
, TIOCSETD
, &ldisc
);
1811 /* In 4.3BSD, the TIOCSPGRP bug has been fixed, and now you
1812 can do TIOCSPGRP only to the process's controlling tty. */
1815 /* I wonder: would just ioctl (0, TIOCNOTTY, 0) work here?
1816 I can't test it since I don't have 4.3. */
1817 int j
= emacs_open ("/dev/tty", O_RDWR
, 0);
1820 ioctl (j
, TIOCNOTTY
, 0);
1824 /* In order to get a controlling terminal on some versions
1825 of BSD, it is necessary to put the process in pgrp 0
1826 before it opens the terminal. */
1834 #endif /* TIOCNOTTY */
1836 #if !defined (DONT_REOPEN_PTY)
1837 /*** There is a suggestion that this ought to be a
1838 conditional on TIOCSPGRP,
1839 or !(defined (HAVE_SETSID) && defined (TIOCSCTTY)).
1840 Trying the latter gave the wrong results on Debian GNU/Linux 1.1;
1841 that system does seem to need this code, even though
1842 both HAVE_SETSID and TIOCSCTTY are defined. */
1843 /* Now close the pty (if we had it open) and reopen it.
1844 This makes the pty the controlling terminal of the subprocess. */
1848 /* I wonder if emacs_close (emacs_open (pty_name, ...))
1851 emacs_close (xforkin
);
1852 xforkout
= xforkin
= emacs_open (pty_name
, O_RDWR
, 0);
1856 emacs_write (1, "Couldn't open the pty terminal ", 31);
1857 emacs_write (1, pty_name
, strlen (pty_name
));
1858 emacs_write (1, "\n", 1);
1863 #endif /* not DONT_REOPEN_PTY */
1865 #ifdef SETUP_SLAVE_PTY
1870 #endif /* SETUP_SLAVE_PTY */
1872 /* On AIX, we've disabled SIGHUP above once we start a child on a pty.
1873 Now reenable it in the child, so it will die when we want it to. */
1875 signal (SIGHUP
, SIG_DFL
);
1877 #endif /* HAVE_PTYS */
1879 signal (SIGINT
, SIG_DFL
);
1880 signal (SIGQUIT
, SIG_DFL
);
1881 /* GConf causes us to ignore SIGPIPE, make sure it is restored
1883 signal (SIGPIPE
, SIG_DFL
);
1885 /* Stop blocking signals in the child. */
1886 pthread_sigmask (SIG_SETMASK
, &procmask
, 0);
1889 child_setup_tty (xforkout
);
1891 pid
= child_setup (xforkin
, xforkout
, xforkout
,
1892 new_argv
, 1, encoded_current_dir
);
1893 #else /* not WINDOWSNT */
1895 emacs_close (wait_child_setup
[0]);
1897 child_setup (xforkin
, xforkout
, xforkout
,
1898 new_argv
, 1, encoded_current_dir
);
1899 #endif /* not WINDOWSNT */
1901 environ
= save_environ
;
1906 /* This runs in the Emacs process. */
1910 emacs_close (forkin
);
1911 if (forkin
!= forkout
&& forkout
>= 0)
1912 emacs_close (forkout
);
1916 /* vfork succeeded. */
1917 XPROCESS (process
)->pid
= pid
;
1920 register_child (pid
, inchannel
);
1921 #endif /* WINDOWSNT */
1923 /* If the subfork execv fails, and it exits,
1924 this close hangs. I don't know why.
1925 So have an interrupt jar it loose. */
1927 struct atimer
*timer
;
1928 EMACS_TIME offset
= make_emacs_time (1, 0);
1931 timer
= start_atimer (ATIMER_RELATIVE
, offset
, create_process_1
, 0);
1934 emacs_close (forkin
);
1936 cancel_atimer (timer
);
1940 if (forkin
!= forkout
&& forkout
>= 0)
1941 emacs_close (forkout
);
1945 pset_tty_name (XPROCESS (process
), build_string (pty_name
));
1948 pset_tty_name (XPROCESS (process
), Qnil
);
1950 #if !defined (WINDOWSNT) && defined (FD_CLOEXEC)
1951 /* Wait for child_setup to complete in case that vfork is
1952 actually defined as fork. The descriptor wait_child_setup[1]
1953 of a pipe is closed at the child side either by close-on-exec
1954 on successful execvp or the _exit call in child_setup. */
1958 emacs_close (wait_child_setup
[1]);
1959 emacs_read (wait_child_setup
[0], &dummy
, 1);
1960 emacs_close (wait_child_setup
[0]);
1965 /* Restore the signal state whether vfork succeeded or not.
1966 (We will signal an error, below, if it failed.) */
1967 #ifdef HAVE_WORKING_VFORK
1968 /* Restore the parent's signal handlers. */
1969 sigaction (SIGINT
, &sigint_action
, 0);
1970 sigaction (SIGQUIT
, &sigquit_action
, 0);
1971 sigaction (SIGPIPE
, &sigpipe_action
, 0);
1973 sigaction (SIGHUP
, &sighup_action
, 0);
1975 #endif /* HAVE_WORKING_VFORK */
1976 /* Stop blocking signals in the parent. */
1977 pthread_sigmask (SIG_SETMASK
, &procmask
, 0);
1979 /* Now generate the error if vfork failed. */
1981 report_file_error ("Doing vfork", Qnil
);
1985 create_pty (Lisp_Object process
)
1987 int inchannel
, outchannel
;
1990 inchannel
= outchannel
= -1;
1993 if (!NILP (Vprocess_connection_type
))
1994 outchannel
= inchannel
= allocate_pty ();
1998 #if ! defined (USG) || defined (USG_SUBTTY_WORKS)
1999 /* On most USG systems it does not work to open the pty's tty here,
2000 then close it and reopen it in the child. */
2002 /* Don't let this terminal become our controlling terminal
2003 (in case we don't have one). */
2004 int forkout
= emacs_open (pty_name
, O_RDWR
| O_NOCTTY
, 0);
2006 int forkout
= emacs_open (pty_name
, O_RDWR
, 0);
2009 report_file_error ("Opening pty", Qnil
);
2010 #if defined (DONT_REOPEN_PTY)
2011 /* In the case that vfork is defined as fork, the parent process
2012 (Emacs) may send some data before the child process completes
2013 tty options setup. So we setup tty before forking. */
2014 child_setup_tty (forkout
);
2015 #endif /* DONT_REOPEN_PTY */
2016 #endif /* not USG, or USG_SUBTTY_WORKS */
2019 #endif /* HAVE_PTYS */
2022 fcntl (inchannel
, F_SETFL
, O_NONBLOCK
);
2023 fcntl (outchannel
, F_SETFL
, O_NONBLOCK
);
2026 fcntl (inchannel
, F_SETFL
, O_NDELAY
);
2027 fcntl (outchannel
, F_SETFL
, O_NDELAY
);
2031 /* Record this as an active process, with its channels.
2032 As a result, child_setup will close Emacs's side of the pipes. */
2033 chan_process
[inchannel
] = process
;
2034 XPROCESS (process
)->infd
= inchannel
;
2035 XPROCESS (process
)->outfd
= outchannel
;
2037 /* Previously we recorded the tty descriptor used in the subprocess.
2038 It was only used for getting the foreground tty process, so now
2039 we just reopen the device (see emacs_get_tty_pgrp) as this is
2040 more portable (see USG_SUBTTY_WORKS above). */
2042 XPROCESS (process
)->pty_flag
= pty_flag
;
2043 pset_status (XPROCESS (process
), Qrun
);
2044 setup_process_coding_systems (process
);
2046 FD_SET (inchannel
, &input_wait_mask
);
2047 FD_SET (inchannel
, &non_keyboard_wait_mask
);
2048 if (inchannel
> max_process_desc
)
2049 max_process_desc
= inchannel
;
2051 XPROCESS (process
)->pid
= -2;
2054 pset_tty_name (XPROCESS (process
), build_string (pty_name
));
2057 pset_tty_name (XPROCESS (process
), Qnil
);
2061 /* Convert an internal struct sockaddr to a lisp object (vector or string).
2062 The address family of sa is not included in the result. */
2065 conv_sockaddr_to_lisp (struct sockaddr
*sa
, int len
)
2067 Lisp_Object address
;
2070 register struct Lisp_Vector
*p
;
2072 /* Workaround for a bug in getsockname on BSD: Names bound to
2073 sockets in the UNIX domain are inaccessible; getsockname returns
2074 a zero length name. */
2075 if (len
< offsetof (struct sockaddr
, sa_family
) + sizeof (sa
->sa_family
))
2076 return empty_unibyte_string
;
2078 switch (sa
->sa_family
)
2082 struct sockaddr_in
*sin
= (struct sockaddr_in
*) sa
;
2083 len
= sizeof (sin
->sin_addr
) + 1;
2084 address
= Fmake_vector (make_number (len
), Qnil
);
2085 p
= XVECTOR (address
);
2086 p
->contents
[--len
] = make_number (ntohs (sin
->sin_port
));
2087 cp
= (unsigned char *) &sin
->sin_addr
;
2093 struct sockaddr_in6
*sin6
= (struct sockaddr_in6
*) sa
;
2094 uint16_t *ip6
= (uint16_t *) &sin6
->sin6_addr
;
2095 len
= sizeof (sin6
->sin6_addr
)/2 + 1;
2096 address
= Fmake_vector (make_number (len
), Qnil
);
2097 p
= XVECTOR (address
);
2098 p
->contents
[--len
] = make_number (ntohs (sin6
->sin6_port
));
2099 for (i
= 0; i
< len
; i
++)
2100 p
->contents
[i
] = make_number (ntohs (ip6
[i
]));
2104 #ifdef HAVE_LOCAL_SOCKETS
2107 struct sockaddr_un
*sockun
= (struct sockaddr_un
*) sa
;
2108 for (i
= 0; i
< sizeof (sockun
->sun_path
); i
++)
2109 if (sockun
->sun_path
[i
] == 0)
2111 return make_unibyte_string (sockun
->sun_path
, i
);
2115 len
-= offsetof (struct sockaddr
, sa_family
) + sizeof (sa
->sa_family
);
2116 address
= Fcons (make_number (sa
->sa_family
),
2117 Fmake_vector (make_number (len
), Qnil
));
2118 p
= XVECTOR (XCDR (address
));
2119 cp
= (unsigned char *) &sa
->sa_family
+ sizeof (sa
->sa_family
);
2125 p
->contents
[i
++] = make_number (*cp
++);
2131 /* Get family and required size for sockaddr structure to hold ADDRESS. */
2134 get_lisp_to_sockaddr_size (Lisp_Object address
, int *familyp
)
2136 register struct Lisp_Vector
*p
;
2138 if (VECTORP (address
))
2140 p
= XVECTOR (address
);
2141 if (p
->header
.size
== 5)
2144 return sizeof (struct sockaddr_in
);
2147 else if (p
->header
.size
== 9)
2149 *familyp
= AF_INET6
;
2150 return sizeof (struct sockaddr_in6
);
2154 #ifdef HAVE_LOCAL_SOCKETS
2155 else if (STRINGP (address
))
2157 *familyp
= AF_LOCAL
;
2158 return sizeof (struct sockaddr_un
);
2161 else if (CONSP (address
) && TYPE_RANGED_INTEGERP (int, XCAR (address
))
2162 && VECTORP (XCDR (address
)))
2164 struct sockaddr
*sa
;
2165 *familyp
= XINT (XCAR (address
));
2166 p
= XVECTOR (XCDR (address
));
2167 return p
->header
.size
+ sizeof (sa
->sa_family
);
2172 /* Convert an address object (vector or string) to an internal sockaddr.
2174 The address format has been basically validated by
2175 get_lisp_to_sockaddr_size, but this does not mean FAMILY is valid;
2176 it could have come from user data. So if FAMILY is not valid,
2177 we return after zeroing *SA. */
2180 conv_lisp_to_sockaddr (int family
, Lisp_Object address
, struct sockaddr
*sa
, int len
)
2182 register struct Lisp_Vector
*p
;
2183 register unsigned char *cp
= NULL
;
2187 memset (sa
, 0, len
);
2189 if (VECTORP (address
))
2191 p
= XVECTOR (address
);
2192 if (family
== AF_INET
)
2194 struct sockaddr_in
*sin
= (struct sockaddr_in
*) sa
;
2195 len
= sizeof (sin
->sin_addr
) + 1;
2196 hostport
= XINT (p
->contents
[--len
]);
2197 sin
->sin_port
= htons (hostport
);
2198 cp
= (unsigned char *)&sin
->sin_addr
;
2199 sa
->sa_family
= family
;
2202 else if (family
== AF_INET6
)
2204 struct sockaddr_in6
*sin6
= (struct sockaddr_in6
*) sa
;
2205 uint16_t *ip6
= (uint16_t *)&sin6
->sin6_addr
;
2206 len
= sizeof (sin6
->sin6_addr
) + 1;
2207 hostport
= XINT (p
->contents
[--len
]);
2208 sin6
->sin6_port
= htons (hostport
);
2209 for (i
= 0; i
< len
; i
++)
2210 if (INTEGERP (p
->contents
[i
]))
2212 int j
= XFASTINT (p
->contents
[i
]) & 0xffff;
2215 sa
->sa_family
= family
;
2222 else if (STRINGP (address
))
2224 #ifdef HAVE_LOCAL_SOCKETS
2225 if (family
== AF_LOCAL
)
2227 struct sockaddr_un
*sockun
= (struct sockaddr_un
*) sa
;
2228 cp
= SDATA (address
);
2229 for (i
= 0; i
< sizeof (sockun
->sun_path
) && *cp
; i
++)
2230 sockun
->sun_path
[i
] = *cp
++;
2231 sa
->sa_family
= family
;
2238 p
= XVECTOR (XCDR (address
));
2239 cp
= (unsigned char *)sa
+ sizeof (sa
->sa_family
);
2242 for (i
= 0; i
< len
; i
++)
2243 if (INTEGERP (p
->contents
[i
]))
2244 *cp
++ = XFASTINT (p
->contents
[i
]) & 0xff;
2247 #ifdef DATAGRAM_SOCKETS
2248 DEFUN ("process-datagram-address", Fprocess_datagram_address
, Sprocess_datagram_address
,
2250 doc
: /* Get the current datagram address associated with PROCESS. */)
2251 (Lisp_Object process
)
2255 CHECK_PROCESS (process
);
2257 if (!DATAGRAM_CONN_P (process
))
2260 channel
= XPROCESS (process
)->infd
;
2261 return conv_sockaddr_to_lisp (datagram_address
[channel
].sa
,
2262 datagram_address
[channel
].len
);
2265 DEFUN ("set-process-datagram-address", Fset_process_datagram_address
, Sset_process_datagram_address
,
2267 doc
: /* Set the datagram address for PROCESS to ADDRESS.
2268 Returns nil upon error setting address, ADDRESS otherwise. */)
2269 (Lisp_Object process
, Lisp_Object address
)
2274 CHECK_PROCESS (process
);
2276 if (!DATAGRAM_CONN_P (process
))
2279 channel
= XPROCESS (process
)->infd
;
2281 len
= get_lisp_to_sockaddr_size (address
, &family
);
2282 if (datagram_address
[channel
].len
!= len
)
2284 conv_lisp_to_sockaddr (family
, address
, datagram_address
[channel
].sa
, len
);
2290 static const struct socket_options
{
2291 /* The name of this option. Should be lowercase version of option
2292 name without SO_ prefix. */
2294 /* Option level SOL_... */
2296 /* Option number SO_... */
2298 enum { SOPT_UNKNOWN
, SOPT_BOOL
, SOPT_INT
, SOPT_IFNAME
, SOPT_LINGER
} opttype
;
2299 enum { OPIX_NONE
=0, OPIX_MISC
=1, OPIX_REUSEADDR
=2 } optbit
;
2300 } socket_options
[] =
2302 #ifdef SO_BINDTODEVICE
2303 { ":bindtodevice", SOL_SOCKET
, SO_BINDTODEVICE
, SOPT_IFNAME
, OPIX_MISC
},
2306 { ":broadcast", SOL_SOCKET
, SO_BROADCAST
, SOPT_BOOL
, OPIX_MISC
},
2309 { ":dontroute", SOL_SOCKET
, SO_DONTROUTE
, SOPT_BOOL
, OPIX_MISC
},
2312 { ":keepalive", SOL_SOCKET
, SO_KEEPALIVE
, SOPT_BOOL
, OPIX_MISC
},
2315 { ":linger", SOL_SOCKET
, SO_LINGER
, SOPT_LINGER
, OPIX_MISC
},
2318 { ":oobinline", SOL_SOCKET
, SO_OOBINLINE
, SOPT_BOOL
, OPIX_MISC
},
2321 { ":priority", SOL_SOCKET
, SO_PRIORITY
, SOPT_INT
, OPIX_MISC
},
2324 { ":reuseaddr", SOL_SOCKET
, SO_REUSEADDR
, SOPT_BOOL
, OPIX_REUSEADDR
},
2326 { 0, 0, 0, SOPT_UNKNOWN
, OPIX_NONE
}
2329 /* Set option OPT to value VAL on socket S.
2331 Returns (1<<socket_options[OPT].optbit) if option is known, 0 otherwise.
2332 Signals an error if setting a known option fails.
2336 set_socket_option (int s
, Lisp_Object opt
, Lisp_Object val
)
2339 const struct socket_options
*sopt
;
2344 name
= SSDATA (SYMBOL_NAME (opt
));
2345 for (sopt
= socket_options
; sopt
->name
; sopt
++)
2346 if (strcmp (name
, sopt
->name
) == 0)
2349 switch (sopt
->opttype
)
2354 optval
= NILP (val
) ? 0 : 1;
2355 ret
= setsockopt (s
, sopt
->optlevel
, sopt
->optnum
,
2356 &optval
, sizeof (optval
));
2363 if (TYPE_RANGED_INTEGERP (int, val
))
2364 optval
= XINT (val
);
2366 error ("Bad option value for %s", name
);
2367 ret
= setsockopt (s
, sopt
->optlevel
, sopt
->optnum
,
2368 &optval
, sizeof (optval
));
2372 #ifdef SO_BINDTODEVICE
2375 char devname
[IFNAMSIZ
+1];
2377 /* This is broken, at least in the Linux 2.4 kernel.
2378 To unbind, the arg must be a zero integer, not the empty string.
2379 This should work on all systems. KFS. 2003-09-23. */
2380 memset (devname
, 0, sizeof devname
);
2383 char *arg
= SSDATA (val
);
2384 int len
= min (strlen (arg
), IFNAMSIZ
);
2385 memcpy (devname
, arg
, len
);
2387 else if (!NILP (val
))
2388 error ("Bad option value for %s", name
);
2389 ret
= setsockopt (s
, sopt
->optlevel
, sopt
->optnum
,
2398 struct linger linger
;
2401 linger
.l_linger
= 0;
2402 if (TYPE_RANGED_INTEGERP (int, val
))
2403 linger
.l_linger
= XINT (val
);
2405 linger
.l_onoff
= NILP (val
) ? 0 : 1;
2406 ret
= setsockopt (s
, sopt
->optlevel
, sopt
->optnum
,
2407 &linger
, sizeof (linger
));
2417 report_file_error ("Cannot set network option",
2418 Fcons (opt
, Fcons (val
, Qnil
)));
2419 return (1 << sopt
->optbit
);
2423 DEFUN ("set-network-process-option",
2424 Fset_network_process_option
, Sset_network_process_option
,
2426 doc
: /* For network process PROCESS set option OPTION to value VALUE.
2427 See `make-network-process' for a list of options and values.
2428 If optional fourth arg NO-ERROR is non-nil, don't signal an error if
2429 OPTION is not a supported option, return nil instead; otherwise return t. */)
2430 (Lisp_Object process
, Lisp_Object option
, Lisp_Object value
, Lisp_Object no_error
)
2433 struct Lisp_Process
*p
;
2435 CHECK_PROCESS (process
);
2436 p
= XPROCESS (process
);
2437 if (!NETCONN1_P (p
))
2438 error ("Process is not a network process");
2442 error ("Process is not running");
2444 if (set_socket_option (s
, option
, value
))
2446 pset_childp (p
, Fplist_put (p
->childp
, option
, value
));
2450 if (NILP (no_error
))
2451 error ("Unknown or unsupported option");
2457 DEFUN ("serial-process-configure",
2458 Fserial_process_configure
,
2459 Sserial_process_configure
,
2461 doc
: /* Configure speed, bytesize, etc. of a serial process.
2463 Arguments are specified as keyword/argument pairs. Attributes that
2464 are not given are re-initialized from the process's current
2465 configuration (available via the function `process-contact') or set to
2466 reasonable default values. The following arguments are defined:
2472 -- Any of these arguments can be given to identify the process that is
2473 to be configured. If none of these arguments is given, the current
2474 buffer's process is used.
2476 :speed SPEED -- SPEED is the speed of the serial port in bits per
2477 second, also called baud rate. Any value can be given for SPEED, but
2478 most serial ports work only at a few defined values between 1200 and
2479 115200, with 9600 being the most common value. If SPEED is nil, the
2480 serial port is not configured any further, i.e., all other arguments
2481 are ignored. This may be useful for special serial ports such as
2482 Bluetooth-to-serial converters which can only be configured through AT
2483 commands. A value of nil for SPEED can be used only when passed
2484 through `make-serial-process' or `serial-term'.
2486 :bytesize BYTESIZE -- BYTESIZE is the number of bits per byte, which
2487 can be 7 or 8. If BYTESIZE is not given or nil, a value of 8 is used.
2489 :parity PARITY -- PARITY can be nil (don't use parity), the symbol
2490 `odd' (use odd parity), or the symbol `even' (use even parity). If
2491 PARITY is not given, no parity is used.
2493 :stopbits STOPBITS -- STOPBITS is the number of stopbits used to
2494 terminate a byte transmission. STOPBITS can be 1 or 2. If STOPBITS
2495 is not given or nil, 1 stopbit is used.
2497 :flowcontrol FLOWCONTROL -- FLOWCONTROL determines the type of
2498 flowcontrol to be used, which is either nil (don't use flowcontrol),
2499 the symbol `hw' (use RTS/CTS hardware flowcontrol), or the symbol `sw'
2500 \(use XON/XOFF software flowcontrol). If FLOWCONTROL is not given, no
2501 flowcontrol is used.
2503 `serial-process-configure' is called by `make-serial-process' for the
2504 initial configuration of the serial port.
2508 \(serial-process-configure :process "/dev/ttyS0" :speed 1200)
2510 \(serial-process-configure
2511 :buffer "COM1" :stopbits 1 :parity 'odd :flowcontrol 'hw)
2513 \(serial-process-configure :port "\\\\.\\COM13" :bytesize 7)
2515 usage: (serial-process-configure &rest ARGS) */)
2516 (ptrdiff_t nargs
, Lisp_Object
*args
)
2518 struct Lisp_Process
*p
;
2519 Lisp_Object contact
= Qnil
;
2520 Lisp_Object proc
= Qnil
;
2521 struct gcpro gcpro1
;
2523 contact
= Flist (nargs
, args
);
2526 proc
= Fplist_get (contact
, QCprocess
);
2528 proc
= Fplist_get (contact
, QCname
);
2530 proc
= Fplist_get (contact
, QCbuffer
);
2532 proc
= Fplist_get (contact
, QCport
);
2533 proc
= get_process (proc
);
2534 p
= XPROCESS (proc
);
2535 if (!EQ (p
->type
, Qserial
))
2536 error ("Not a serial process");
2538 if (NILP (Fplist_get (p
->childp
, QCspeed
)))
2544 serial_configure (p
, contact
);
2550 /* Used by make-serial-process to recover from errors. */
2552 make_serial_process_unwind (Lisp_Object proc
)
2554 if (!PROCESSP (proc
))
2556 remove_process (proc
);
2560 DEFUN ("make-serial-process", Fmake_serial_process
, Smake_serial_process
,
2562 doc
: /* Create and return a serial port process.
2564 In Emacs, serial port connections are represented by process objects,
2565 so input and output work as for subprocesses, and `delete-process'
2566 closes a serial port connection. However, a serial process has no
2567 process id, it cannot be signaled, and the status codes are different
2568 from normal processes.
2570 `make-serial-process' creates a process and a buffer, on which you
2571 probably want to use `process-send-string'. Try \\[serial-term] for
2572 an interactive terminal. See below for examples.
2574 Arguments are specified as keyword/argument pairs. The following
2575 arguments are defined:
2577 :port PORT -- (mandatory) PORT is the path or name of the serial port.
2578 For example, this could be "/dev/ttyS0" on Unix. On Windows, this
2579 could be "COM1", or "\\\\.\\COM10" for ports higher than COM9 (double
2580 the backslashes in strings).
2582 :speed SPEED -- (mandatory) is handled by `serial-process-configure',
2583 which this function calls.
2585 :name NAME -- NAME is the name of the process. If NAME is not given,
2586 the value of PORT is used.
2588 :buffer BUFFER -- BUFFER is the buffer (or buffer-name) to associate
2589 with the process. Process output goes at the end of that buffer,
2590 unless you specify an output stream or filter function to handle the
2591 output. If BUFFER is not given, the value of NAME is used.
2593 :coding CODING -- If CODING is a symbol, it specifies the coding
2594 system used for both reading and writing for this process. If CODING
2595 is a cons (DECODING . ENCODING), DECODING is used for reading, and
2596 ENCODING is used for writing.
2598 :noquery BOOL -- When exiting Emacs, query the user if BOOL is nil and
2599 the process is running. If BOOL is not given, query before exiting.
2601 :stop BOOL -- Start process in the `stopped' state if BOOL is non-nil.
2602 In the stopped state, a serial process does not accept incoming data,
2603 but you can send outgoing data. The stopped state is cleared by
2604 `continue-process' and set by `stop-process'.
2606 :filter FILTER -- Install FILTER as the process filter.
2608 :sentinel SENTINEL -- Install SENTINEL as the process sentinel.
2610 :plist PLIST -- Install PLIST as the initial plist of the process.
2616 -- This function calls `serial-process-configure' to handle these
2619 The original argument list, possibly modified by later configuration,
2620 is available via the function `process-contact'.
2624 \(make-serial-process :port "/dev/ttyS0" :speed 9600)
2626 \(make-serial-process :port "COM1" :speed 115200 :stopbits 2)
2628 \(make-serial-process :port "\\\\.\\COM13" :speed 1200 :bytesize 7 :parity 'odd)
2630 \(make-serial-process :port "/dev/tty.BlueConsole-SPP-1" :speed nil)
2632 usage: (make-serial-process &rest ARGS) */)
2633 (ptrdiff_t nargs
, Lisp_Object
*args
)
2636 Lisp_Object proc
, contact
, port
;
2637 struct Lisp_Process
*p
;
2638 struct gcpro gcpro1
;
2639 Lisp_Object name
, buffer
;
2640 Lisp_Object tem
, val
;
2641 ptrdiff_t specpdl_count
= -1;
2646 contact
= Flist (nargs
, args
);
2649 port
= Fplist_get (contact
, QCport
);
2651 error ("No port specified");
2652 CHECK_STRING (port
);
2654 if (NILP (Fplist_member (contact
, QCspeed
)))
2655 error (":speed not specified");
2656 if (!NILP (Fplist_get (contact
, QCspeed
)))
2657 CHECK_NUMBER (Fplist_get (contact
, QCspeed
));
2659 name
= Fplist_get (contact
, QCname
);
2662 CHECK_STRING (name
);
2663 proc
= make_process (name
);
2664 specpdl_count
= SPECPDL_INDEX ();
2665 record_unwind_protect (make_serial_process_unwind
, proc
);
2666 p
= XPROCESS (proc
);
2668 fd
= serial_open (SSDATA (port
));
2671 if (fd
> max_process_desc
)
2672 max_process_desc
= fd
;
2673 chan_process
[fd
] = proc
;
2675 buffer
= Fplist_get (contact
, QCbuffer
);
2678 buffer
= Fget_buffer_create (buffer
);
2679 pset_buffer (p
, buffer
);
2681 pset_childp (p
, contact
);
2682 pset_plist (p
, Fcopy_sequence (Fplist_get (contact
, QCplist
)));
2683 pset_type (p
, Qserial
);
2684 pset_sentinel (p
, Fplist_get (contact
, QCsentinel
));
2685 pset_filter (p
, Fplist_get (contact
, QCfilter
));
2687 if (tem
= Fplist_get (contact
, QCnoquery
), !NILP (tem
))
2688 p
->kill_without_query
= 1;
2689 if (tem
= Fplist_get (contact
, QCstop
), !NILP (tem
))
2690 pset_command (p
, Qt
);
2693 if (!EQ (p
->command
, Qt
))
2695 FD_SET (fd
, &input_wait_mask
);
2696 FD_SET (fd
, &non_keyboard_wait_mask
);
2699 if (BUFFERP (buffer
))
2701 set_marker_both (p
->mark
, buffer
,
2702 BUF_ZV (XBUFFER (buffer
)),
2703 BUF_ZV_BYTE (XBUFFER (buffer
)));
2706 tem
= Fplist_member (contact
, QCcoding
);
2707 if (!NILP (tem
) && (!CONSP (tem
) || !CONSP (XCDR (tem
))))
2713 val
= XCAR (XCDR (tem
));
2717 else if (!NILP (Vcoding_system_for_read
))
2718 val
= Vcoding_system_for_read
;
2719 else if ((!NILP (buffer
) && NILP (BVAR (XBUFFER (buffer
), enable_multibyte_characters
)))
2720 || (NILP (buffer
) && NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
))))
2722 pset_decode_coding_system (p
, val
);
2727 val
= XCAR (XCDR (tem
));
2731 else if (!NILP (Vcoding_system_for_write
))
2732 val
= Vcoding_system_for_write
;
2733 else if ((!NILP (buffer
) && NILP (BVAR (XBUFFER (buffer
), enable_multibyte_characters
)))
2734 || (NILP (buffer
) && NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
))))
2736 pset_encode_coding_system (p
, val
);
2738 setup_process_coding_systems (proc
);
2739 pset_decoding_buf (p
, empty_unibyte_string
);
2740 p
->decoding_carryover
= 0;
2741 pset_encoding_buf (p
, empty_unibyte_string
);
2742 p
->inherit_coding_system_flag
2743 = !(!NILP (tem
) || NILP (buffer
) || !inherit_process_coding_system
);
2745 Fserial_process_configure (nargs
, args
);
2747 specpdl_ptr
= specpdl
+ specpdl_count
;
2753 /* Create a network stream/datagram client/server process. Treated
2754 exactly like a normal process when reading and writing. Primary
2755 differences are in status display and process deletion. A network
2756 connection has no PID; you cannot signal it. All you can do is
2757 stop/continue it and deactivate/close it via delete-process */
2759 DEFUN ("make-network-process", Fmake_network_process
, Smake_network_process
,
2761 doc
: /* Create and return a network server or client process.
2763 In Emacs, network connections are represented by process objects, so
2764 input and output work as for subprocesses and `delete-process' closes
2765 a network connection. However, a network process has no process id,
2766 it cannot be signaled, and the status codes are different from normal
2769 Arguments are specified as keyword/argument pairs. The following
2770 arguments are defined:
2772 :name NAME -- NAME is name for process. It is modified if necessary
2775 :buffer BUFFER -- BUFFER is the buffer (or buffer-name) to associate
2776 with the process. Process output goes at end of that buffer, unless
2777 you specify an output stream or filter function to handle the output.
2778 BUFFER may be also nil, meaning that this process is not associated
2781 :host HOST -- HOST is name of the host to connect to, or its IP
2782 address. The symbol `local' specifies the local host. If specified
2783 for a server process, it must be a valid name or address for the local
2784 host, and only clients connecting to that address will be accepted.
2786 :service SERVICE -- SERVICE is name of the service desired, or an
2787 integer specifying a port number to connect to. If SERVICE is t,
2788 a random port number is selected for the server. (If Emacs was
2789 compiled with getaddrinfo, a port number can also be specified as a
2790 string, e.g. "80", as well as an integer. This is not portable.)
2792 :type TYPE -- TYPE is the type of connection. The default (nil) is a
2793 stream type connection, `datagram' creates a datagram type connection,
2794 `seqpacket' creates a reliable datagram connection.
2796 :family FAMILY -- FAMILY is the address (and protocol) family for the
2797 service specified by HOST and SERVICE. The default (nil) is to use
2798 whatever address family (IPv4 or IPv6) that is defined for the host
2799 and port number specified by HOST and SERVICE. Other address families
2801 local -- for a local (i.e. UNIX) address specified by SERVICE.
2802 ipv4 -- use IPv4 address family only.
2803 ipv6 -- use IPv6 address family only.
2805 :local ADDRESS -- ADDRESS is the local address used for the connection.
2806 This parameter is ignored when opening a client process. When specified
2807 for a server process, the FAMILY, HOST and SERVICE args are ignored.
2809 :remote ADDRESS -- ADDRESS is the remote partner's address for the
2810 connection. This parameter is ignored when opening a stream server
2811 process. For a datagram server process, it specifies the initial
2812 setting of the remote datagram address. When specified for a client
2813 process, the FAMILY, HOST, and SERVICE args are ignored.
2815 The format of ADDRESS depends on the address family:
2816 - An IPv4 address is represented as an vector of integers [A B C D P]
2817 corresponding to numeric IP address A.B.C.D and port number P.
2818 - A local address is represented as a string with the address in the
2819 local address space.
2820 - An "unsupported family" address is represented by a cons (F . AV)
2821 where F is the family number and AV is a vector containing the socket
2822 address data with one element per address data byte. Do not rely on
2823 this format in portable code, as it may depend on implementation
2824 defined constants, data sizes, and data structure alignment.
2826 :coding CODING -- If CODING is a symbol, it specifies the coding
2827 system used for both reading and writing for this process. If CODING
2828 is a cons (DECODING . ENCODING), DECODING is used for reading, and
2829 ENCODING is used for writing.
2831 :nowait BOOL -- If BOOL is non-nil for a stream type client process,
2832 return without waiting for the connection to complete; instead, the
2833 sentinel function will be called with second arg matching "open" (if
2834 successful) or "failed" when the connect completes. Default is to use
2835 a blocking connect (i.e. wait) for stream type connections.
2837 :noquery BOOL -- Query the user unless BOOL is non-nil, and process is
2838 running when Emacs is exited.
2840 :stop BOOL -- Start process in the `stopped' state if BOOL non-nil.
2841 In the stopped state, a server process does not accept new
2842 connections, and a client process does not handle incoming traffic.
2843 The stopped state is cleared by `continue-process' and set by
2846 :filter FILTER -- Install FILTER as the process filter.
2848 :filter-multibyte BOOL -- If BOOL is non-nil, strings given to the
2849 process filter are multibyte, otherwise they are unibyte.
2850 If this keyword is not specified, the strings are multibyte if
2851 the default value of `enable-multibyte-characters' is non-nil.
2853 :sentinel SENTINEL -- Install SENTINEL as the process sentinel.
2855 :log LOG -- Install LOG as the server process log function. This
2856 function is called when the server accepts a network connection from a
2857 client. The arguments are SERVER, CLIENT, and MESSAGE, where SERVER
2858 is the server process, CLIENT is the new process for the connection,
2859 and MESSAGE is a string.
2861 :plist PLIST -- Install PLIST as the new process' initial plist.
2863 :server QLEN -- if QLEN is non-nil, create a server process for the
2864 specified FAMILY, SERVICE, and connection type (stream or datagram).
2865 If QLEN is an integer, it is used as the max. length of the server's
2866 pending connection queue (also known as the backlog); the default
2867 queue length is 5. Default is to create a client process.
2869 The following network options can be specified for this connection:
2871 :broadcast BOOL -- Allow send and receive of datagram broadcasts.
2872 :dontroute BOOL -- Only send to directly connected hosts.
2873 :keepalive BOOL -- Send keep-alive messages on network stream.
2874 :linger BOOL or TIMEOUT -- Send queued messages before closing.
2875 :oobinline BOOL -- Place out-of-band data in receive data stream.
2876 :priority INT -- Set protocol defined priority for sent packets.
2877 :reuseaddr BOOL -- Allow reusing a recently used local address
2878 (this is allowed by default for a server process).
2879 :bindtodevice NAME -- bind to interface NAME. Using this may require
2880 special privileges on some systems.
2882 Consult the relevant system programmer's manual pages for more
2883 information on using these options.
2886 A server process will listen for and accept connections from clients.
2887 When a client connection is accepted, a new network process is created
2888 for the connection with the following parameters:
2890 - The client's process name is constructed by concatenating the server
2891 process' NAME and a client identification string.
2892 - If the FILTER argument is non-nil, the client process will not get a
2893 separate process buffer; otherwise, the client's process buffer is a newly
2894 created buffer named after the server process' BUFFER name or process
2895 NAME concatenated with the client identification string.
2896 - The connection type and the process filter and sentinel parameters are
2897 inherited from the server process' TYPE, FILTER and SENTINEL.
2898 - The client process' contact info is set according to the client's
2899 addressing information (typically an IP address and a port number).
2900 - The client process' plist is initialized from the server's plist.
2902 Notice that the FILTER and SENTINEL args are never used directly by
2903 the server process. Also, the BUFFER argument is not used directly by
2904 the server process, but via the optional :log function, accepted (and
2905 failed) connections may be logged in the server process' buffer.
2907 The original argument list, modified with the actual connection
2908 information, is available via the `process-contact' function.
2910 usage: (make-network-process &rest ARGS) */)
2911 (ptrdiff_t nargs
, Lisp_Object
*args
)
2914 Lisp_Object contact
;
2915 struct Lisp_Process
*p
;
2916 #ifdef HAVE_GETADDRINFO
2917 struct addrinfo ai
, *res
, *lres
;
2918 struct addrinfo hints
;
2919 const char *portstring
;
2921 #else /* HAVE_GETADDRINFO */
2922 struct _emacs_addrinfo
2928 struct sockaddr
*ai_addr
;
2929 struct _emacs_addrinfo
*ai_next
;
2931 #endif /* HAVE_GETADDRINFO */
2932 struct sockaddr_in address_in
;
2933 #ifdef HAVE_LOCAL_SOCKETS
2934 struct sockaddr_un address_un
;
2939 int s
= -1, outch
, inch
;
2940 struct gcpro gcpro1
;
2941 ptrdiff_t count
= SPECPDL_INDEX ();
2943 Lisp_Object QCaddress
; /* one of QClocal or QCremote */
2945 Lisp_Object name
, buffer
, host
, service
, address
;
2946 Lisp_Object filter
, sentinel
;
2947 int is_non_blocking_client
= 0;
2948 int is_server
= 0, backlog
= 5;
2955 /* Save arguments for process-contact and clone-process. */
2956 contact
= Flist (nargs
, args
);
2960 /* Ensure socket support is loaded if available. */
2961 init_winsock (TRUE
);
2964 /* :type TYPE (nil: stream, datagram */
2965 tem
= Fplist_get (contact
, QCtype
);
2967 socktype
= SOCK_STREAM
;
2968 #ifdef DATAGRAM_SOCKETS
2969 else if (EQ (tem
, Qdatagram
))
2970 socktype
= SOCK_DGRAM
;
2972 #ifdef HAVE_SEQPACKET
2973 else if (EQ (tem
, Qseqpacket
))
2974 socktype
= SOCK_SEQPACKET
;
2977 error ("Unsupported connection type");
2980 tem
= Fplist_get (contact
, QCserver
);
2983 /* Don't support network sockets when non-blocking mode is
2984 not available, since a blocked Emacs is not useful. */
2985 #if !defined (O_NONBLOCK) && !defined (O_NDELAY)
2986 error ("Network servers not supported");
2989 if (TYPE_RANGED_INTEGERP (int, tem
))
2990 backlog
= XINT (tem
);
2994 /* Make QCaddress an alias for :local (server) or :remote (client). */
2995 QCaddress
= is_server
? QClocal
: QCremote
;
2998 if (!is_server
&& socktype
!= SOCK_DGRAM
2999 && (tem
= Fplist_get (contact
, QCnowait
), !NILP (tem
)))
3001 #ifndef NON_BLOCKING_CONNECT
3002 error ("Non-blocking connect not supported");
3004 is_non_blocking_client
= 1;
3008 name
= Fplist_get (contact
, QCname
);
3009 buffer
= Fplist_get (contact
, QCbuffer
);
3010 filter
= Fplist_get (contact
, QCfilter
);
3011 sentinel
= Fplist_get (contact
, QCsentinel
);
3013 CHECK_STRING (name
);
3015 /* Initialize addrinfo structure in case we don't use getaddrinfo. */
3016 ai
.ai_socktype
= socktype
;
3021 /* :local ADDRESS or :remote ADDRESS */
3022 address
= Fplist_get (contact
, QCaddress
);
3023 if (!NILP (address
))
3025 host
= service
= Qnil
;
3027 if (!(ai
.ai_addrlen
= get_lisp_to_sockaddr_size (address
, &family
)))
3028 error ("Malformed :address");
3029 ai
.ai_family
= family
;
3030 ai
.ai_addr
= alloca (ai
.ai_addrlen
);
3031 conv_lisp_to_sockaddr (family
, address
, ai
.ai_addr
, ai
.ai_addrlen
);
3035 /* :family FAMILY -- nil (for Inet), local, or integer. */
3036 tem
= Fplist_get (contact
, QCfamily
);
3039 #if defined (HAVE_GETADDRINFO) && defined (AF_INET6)
3045 #ifdef HAVE_LOCAL_SOCKETS
3046 else if (EQ (tem
, Qlocal
))
3050 else if (EQ (tem
, Qipv6
))
3053 else if (EQ (tem
, Qipv4
))
3055 else if (TYPE_RANGED_INTEGERP (int, tem
))
3056 family
= XINT (tem
);
3058 error ("Unknown address family");
3060 ai
.ai_family
= family
;
3062 /* :service SERVICE -- string, integer (port number), or t (random port). */
3063 service
= Fplist_get (contact
, QCservice
);
3065 /* :host HOST -- hostname, ip address, or 'local for localhost. */
3066 host
= Fplist_get (contact
, QChost
);
3069 if (EQ (host
, Qlocal
))
3070 /* Depending on setup, "localhost" may map to different IPv4 and/or
3071 IPv6 addresses, so it's better to be explicit. (Bug#6781) */
3072 host
= build_string ("127.0.0.1");
3073 CHECK_STRING (host
);
3076 #ifdef HAVE_LOCAL_SOCKETS
3077 if (family
== AF_LOCAL
)
3081 message (":family local ignores the :host \"%s\" property",
3083 contact
= Fplist_put (contact
, QChost
, Qnil
);
3086 CHECK_STRING (service
);
3087 memset (&address_un
, 0, sizeof address_un
);
3088 address_un
.sun_family
= AF_LOCAL
;
3089 if (sizeof address_un
.sun_path
<= SBYTES (service
))
3090 error ("Service name too long");
3091 strcpy (address_un
.sun_path
, SSDATA (service
));
3092 ai
.ai_addr
= (struct sockaddr
*) &address_un
;
3093 ai
.ai_addrlen
= sizeof address_un
;
3098 /* Slow down polling to every ten seconds.
3099 Some kernels have a bug which causes retrying connect to fail
3100 after a connect. Polling can interfere with gethostbyname too. */
3101 #ifdef POLL_FOR_INPUT
3102 if (socktype
!= SOCK_DGRAM
)
3104 record_unwind_protect (unwind_stop_other_atimers
, Qnil
);
3105 bind_polling_period (10);
3109 #ifdef HAVE_GETADDRINFO
3110 /* If we have a host, use getaddrinfo to resolve both host and service.
3111 Otherwise, use getservbyname to lookup the service. */
3115 /* SERVICE can either be a string or int.
3116 Convert to a C string for later use by getaddrinfo. */
3117 if (EQ (service
, Qt
))
3119 else if (INTEGERP (service
))
3121 sprintf (portbuf
, "%"pI
"d", XINT (service
));
3122 portstring
= portbuf
;
3126 CHECK_STRING (service
);
3127 portstring
= SSDATA (service
);
3132 memset (&hints
, 0, sizeof (hints
));
3134 hints
.ai_family
= family
;
3135 hints
.ai_socktype
= socktype
;
3136 hints
.ai_protocol
= 0;
3138 #ifdef HAVE_RES_INIT
3142 ret
= getaddrinfo (SSDATA (host
), portstring
, &hints
, &res
);
3144 #ifdef HAVE_GAI_STRERROR
3145 error ("%s/%s %s", SSDATA (host
), portstring
, gai_strerror (ret
));
3147 error ("%s/%s getaddrinfo error %d", SSDATA (host
), portstring
, ret
);
3153 #endif /* HAVE_GETADDRINFO */
3155 /* We end up here if getaddrinfo is not defined, or in case no hostname
3156 has been specified (e.g. for a local server process). */
3158 if (EQ (service
, Qt
))
3160 else if (INTEGERP (service
))
3161 port
= htons ((unsigned short) XINT (service
));
3164 struct servent
*svc_info
;
3165 CHECK_STRING (service
);
3166 svc_info
= getservbyname (SSDATA (service
),
3167 (socktype
== SOCK_DGRAM
? "udp" : "tcp"));
3169 error ("Unknown service: %s", SDATA (service
));
3170 port
= svc_info
->s_port
;
3173 memset (&address_in
, 0, sizeof address_in
);
3174 address_in
.sin_family
= family
;
3175 address_in
.sin_addr
.s_addr
= INADDR_ANY
;
3176 address_in
.sin_port
= port
;
3178 #ifndef HAVE_GETADDRINFO
3181 struct hostent
*host_info_ptr
;
3183 /* gethostbyname may fail with TRY_AGAIN, but we don't honor that,
3184 as it may `hang' Emacs for a very long time. */
3188 #ifdef HAVE_RES_INIT
3192 host_info_ptr
= gethostbyname (SDATA (host
));
3197 memcpy (&address_in
.sin_addr
, host_info_ptr
->h_addr
,
3198 host_info_ptr
->h_length
);
3199 family
= host_info_ptr
->h_addrtype
;
3200 address_in
.sin_family
= family
;
3203 /* Attempt to interpret host as numeric inet address */
3205 unsigned long numeric_addr
;
3206 numeric_addr
= inet_addr (SSDATA (host
));
3207 if (numeric_addr
== -1)
3208 error ("Unknown host \"%s\"", SDATA (host
));
3210 memcpy (&address_in
.sin_addr
, &numeric_addr
,
3211 sizeof (address_in
.sin_addr
));
3215 #endif /* not HAVE_GETADDRINFO */
3217 ai
.ai_family
= family
;
3218 ai
.ai_addr
= (struct sockaddr
*) &address_in
;
3219 ai
.ai_addrlen
= sizeof address_in
;
3223 /* Do this in case we never enter the for-loop below. */
3224 count1
= SPECPDL_INDEX ();
3227 for (lres
= res
; lres
; lres
= lres
->ai_next
)
3236 s
= socket (lres
->ai_family
, lres
->ai_socktype
, lres
->ai_protocol
);
3243 #ifdef DATAGRAM_SOCKETS
3244 if (!is_server
&& socktype
== SOCK_DGRAM
)
3246 #endif /* DATAGRAM_SOCKETS */
3248 #ifdef NON_BLOCKING_CONNECT
3249 if (is_non_blocking_client
)
3252 ret
= fcntl (s
, F_SETFL
, O_NONBLOCK
);
3254 ret
= fcntl (s
, F_SETFL
, O_NDELAY
);
3266 /* Make us close S if quit. */
3267 record_unwind_protect (close_file_unwind
, make_number (s
));
3269 /* Parse network options in the arg list.
3270 We simply ignore anything which isn't a known option (including other keywords).
3271 An error is signaled if setting a known option fails. */
3272 for (optn
= optbits
= 0; optn
< nargs
-1; optn
+= 2)
3273 optbits
|= set_socket_option (s
, args
[optn
], args
[optn
+1]);
3277 /* Configure as a server socket. */
3279 /* SO_REUSEADDR = 1 is default for server sockets; must specify
3280 explicit :reuseaddr key to override this. */
3281 #ifdef HAVE_LOCAL_SOCKETS
3282 if (family
!= AF_LOCAL
)
3284 if (!(optbits
& (1 << OPIX_REUSEADDR
)))
3287 if (setsockopt (s
, SOL_SOCKET
, SO_REUSEADDR
, &optval
, sizeof optval
))
3288 report_file_error ("Cannot set reuse option on server socket", Qnil
);
3291 if (bind (s
, lres
->ai_addr
, lres
->ai_addrlen
))
3292 report_file_error ("Cannot bind server socket", Qnil
);
3294 #ifdef HAVE_GETSOCKNAME
3295 if (EQ (service
, Qt
))
3297 struct sockaddr_in sa1
;
3298 socklen_t len1
= sizeof (sa1
);
3299 if (getsockname (s
, (struct sockaddr
*)&sa1
, &len1
) == 0)
3301 ((struct sockaddr_in
*)(lres
->ai_addr
))->sin_port
= sa1
.sin_port
;
3302 service
= make_number (ntohs (sa1
.sin_port
));
3303 contact
= Fplist_put (contact
, QCservice
, service
);
3308 if (socktype
!= SOCK_DGRAM
&& listen (s
, backlog
))
3309 report_file_error ("Cannot listen on server socket", Qnil
);
3317 ret
= connect (s
, lres
->ai_addr
, lres
->ai_addrlen
);
3320 if (ret
== 0 || xerrno
== EISCONN
)
3322 /* The unwind-protect will be discarded afterwards.
3323 Likewise for immediate_quit. */
3327 #ifdef NON_BLOCKING_CONNECT
3329 if (is_non_blocking_client
&& xerrno
== EINPROGRESS
)
3333 if (is_non_blocking_client
&& xerrno
== EWOULDBLOCK
)
3340 if (xerrno
== EINTR
)
3342 /* Unlike most other syscalls connect() cannot be called
3343 again. (That would return EALREADY.) The proper way to
3344 wait for completion is pselect(). */
3352 sc
= pselect (s
+ 1, NULL
, &fdset
, NULL
, NULL
, NULL
);
3358 report_file_error ("select failed", Qnil
);
3362 len
= sizeof xerrno
;
3363 eassert (FD_ISSET (s
, &fdset
));
3364 if (getsockopt (s
, SOL_SOCKET
, SO_ERROR
, &xerrno
, &len
) == -1)
3365 report_file_error ("getsockopt failed", Qnil
);
3367 errno
= xerrno
, report_file_error ("error during connect", Qnil
);
3371 #endif /* !WINDOWSNT */
3375 /* Discard the unwind protect closing S. */
3376 specpdl_ptr
= specpdl
+ count1
;
3381 if (xerrno
== EINTR
)
3388 #ifdef DATAGRAM_SOCKETS
3389 if (socktype
== SOCK_DGRAM
)
3391 if (datagram_address
[s
].sa
)
3393 datagram_address
[s
].sa
= xmalloc (lres
->ai_addrlen
);
3394 datagram_address
[s
].len
= lres
->ai_addrlen
;
3398 memset (datagram_address
[s
].sa
, 0, lres
->ai_addrlen
);
3399 if (remote
= Fplist_get (contact
, QCremote
), !NILP (remote
))
3402 rlen
= get_lisp_to_sockaddr_size (remote
, &rfamily
);
3403 if (rfamily
== lres
->ai_family
&& rlen
== lres
->ai_addrlen
)
3404 conv_lisp_to_sockaddr (rfamily
, remote
,
3405 datagram_address
[s
].sa
, rlen
);
3409 memcpy (datagram_address
[s
].sa
, lres
->ai_addr
, lres
->ai_addrlen
);
3412 contact
= Fplist_put (contact
, QCaddress
,
3413 conv_sockaddr_to_lisp (lres
->ai_addr
, lres
->ai_addrlen
));
3414 #ifdef HAVE_GETSOCKNAME
3417 struct sockaddr_in sa1
;
3418 socklen_t len1
= sizeof (sa1
);
3419 if (getsockname (s
, (struct sockaddr
*)&sa1
, &len1
) == 0)
3420 contact
= Fplist_put (contact
, QClocal
,
3421 conv_sockaddr_to_lisp ((struct sockaddr
*)&sa1
, len1
));
3428 #ifdef HAVE_GETADDRINFO
3437 /* Discard the unwind protect for closing S, if any. */
3438 specpdl_ptr
= specpdl
+ count1
;
3440 /* Unwind bind_polling_period and request_sigio. */
3441 unbind_to (count
, Qnil
);
3445 /* If non-blocking got this far - and failed - assume non-blocking is
3446 not supported after all. This is probably a wrong assumption, but
3447 the normal blocking calls to open-network-stream handles this error
3449 if (is_non_blocking_client
)
3454 report_file_error ("make server process failed", contact
);
3456 report_file_error ("make client process failed", contact
);
3463 buffer
= Fget_buffer_create (buffer
);
3464 proc
= make_process (name
);
3466 chan_process
[inch
] = proc
;
3469 fcntl (inch
, F_SETFL
, O_NONBLOCK
);
3472 fcntl (inch
, F_SETFL
, O_NDELAY
);
3476 p
= XPROCESS (proc
);
3478 pset_childp (p
, contact
);
3479 pset_plist (p
, Fcopy_sequence (Fplist_get (contact
, QCplist
)));
3480 pset_type (p
, Qnetwork
);
3482 pset_buffer (p
, buffer
);
3483 pset_sentinel (p
, sentinel
);
3484 pset_filter (p
, filter
);
3485 pset_log (p
, Fplist_get (contact
, QClog
));
3486 if (tem
= Fplist_get (contact
, QCnoquery
), !NILP (tem
))
3487 p
->kill_without_query
= 1;
3488 if ((tem
= Fplist_get (contact
, QCstop
), !NILP (tem
)))
3489 pset_command (p
, Qt
);
3493 if (is_server
&& socktype
!= SOCK_DGRAM
)
3494 pset_status (p
, Qlisten
);
3496 /* Make the process marker point into the process buffer (if any). */
3497 if (BUFFERP (buffer
))
3498 set_marker_both (p
->mark
, buffer
,
3499 BUF_ZV (XBUFFER (buffer
)),
3500 BUF_ZV_BYTE (XBUFFER (buffer
)));
3502 #ifdef NON_BLOCKING_CONNECT
3503 if (is_non_blocking_client
)
3505 /* We may get here if connect did succeed immediately. However,
3506 in that case, we still need to signal this like a non-blocking
3508 pset_status (p
, Qconnect
);
3509 if (!FD_ISSET (inch
, &connect_wait_mask
))
3511 FD_SET (inch
, &connect_wait_mask
);
3512 FD_SET (inch
, &write_mask
);
3513 num_pending_connects
++;
3518 /* A server may have a client filter setting of Qt, but it must
3519 still listen for incoming connects unless it is stopped. */
3520 if ((!EQ (p
->filter
, Qt
) && !EQ (p
->command
, Qt
))
3521 || (EQ (p
->status
, Qlisten
) && NILP (p
->command
)))
3523 FD_SET (inch
, &input_wait_mask
);
3524 FD_SET (inch
, &non_keyboard_wait_mask
);
3527 if (inch
> max_process_desc
)
3528 max_process_desc
= inch
;
3530 tem
= Fplist_member (contact
, QCcoding
);
3531 if (!NILP (tem
) && (!CONSP (tem
) || !CONSP (XCDR (tem
))))
3532 tem
= Qnil
; /* No error message (too late!). */
3535 /* Setup coding systems for communicating with the network stream. */
3536 struct gcpro gcpro1
;
3537 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
3538 Lisp_Object coding_systems
= Qt
;
3539 Lisp_Object fargs
[5], val
;
3543 val
= XCAR (XCDR (tem
));
3547 else if (!NILP (Vcoding_system_for_read
))
3548 val
= Vcoding_system_for_read
;
3549 else if ((!NILP (buffer
) && NILP (BVAR (XBUFFER (buffer
), enable_multibyte_characters
)))
3550 || (NILP (buffer
) && NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
))))
3551 /* We dare not decode end-of-line format by setting VAL to
3552 Qraw_text, because the existing Emacs Lisp libraries
3553 assume that they receive bare code including a sequence of
3558 if (NILP (host
) || NILP (service
))
3559 coding_systems
= Qnil
;
3562 fargs
[0] = Qopen_network_stream
, fargs
[1] = name
,
3563 fargs
[2] = buffer
, fargs
[3] = host
, fargs
[4] = service
;
3565 coding_systems
= Ffind_operation_coding_system (5, fargs
);
3568 if (CONSP (coding_systems
))
3569 val
= XCAR (coding_systems
);
3570 else if (CONSP (Vdefault_process_coding_system
))
3571 val
= XCAR (Vdefault_process_coding_system
);
3575 pset_decode_coding_system (p
, val
);
3579 val
= XCAR (XCDR (tem
));
3583 else if (!NILP (Vcoding_system_for_write
))
3584 val
= Vcoding_system_for_write
;
3585 else if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3589 if (EQ (coding_systems
, Qt
))
3591 if (NILP (host
) || NILP (service
))
3592 coding_systems
= Qnil
;
3595 fargs
[0] = Qopen_network_stream
, fargs
[1] = name
,
3596 fargs
[2] = buffer
, fargs
[3] = host
, fargs
[4] = service
;
3598 coding_systems
= Ffind_operation_coding_system (5, fargs
);
3602 if (CONSP (coding_systems
))
3603 val
= XCDR (coding_systems
);
3604 else if (CONSP (Vdefault_process_coding_system
))
3605 val
= XCDR (Vdefault_process_coding_system
);
3609 pset_encode_coding_system (p
, val
);
3611 setup_process_coding_systems (proc
);
3613 pset_decoding_buf (p
, empty_unibyte_string
);
3614 p
->decoding_carryover
= 0;
3615 pset_encoding_buf (p
, empty_unibyte_string
);
3617 p
->inherit_coding_system_flag
3618 = !(!NILP (tem
) || NILP (buffer
) || !inherit_process_coding_system
);
3625 #if defined (HAVE_NET_IF_H)
3628 DEFUN ("network-interface-list", Fnetwork_interface_list
, Snetwork_interface_list
, 0, 0, 0,
3629 doc
: /* Return an alist of all network interfaces and their network address.
3630 Each element is a cons, the car of which is a string containing the
3631 interface name, and the cdr is the network address in internal
3632 format; see the description of ADDRESS in `make-network-process'. */)
3635 struct ifconf ifconf
;
3636 struct ifreq
*ifreq
;
3638 ptrdiff_t buf_size
= 512;
3642 s
= socket (AF_INET
, SOCK_STREAM
, 0);
3648 buf
= xpalloc (buf
, &buf_size
, 1, INT_MAX
, 1);
3649 ifconf
.ifc_buf
= buf
;
3650 ifconf
.ifc_len
= buf_size
;
3651 if (ioctl (s
, SIOCGIFCONF
, &ifconf
))
3658 while (ifconf
.ifc_len
== buf_size
);
3663 ifreq
= ifconf
.ifc_req
;
3664 while ((char *) ifreq
< (char *) ifconf
.ifc_req
+ ifconf
.ifc_len
)
3666 struct ifreq
*ifq
= ifreq
;
3667 #ifdef HAVE_STRUCT_IFREQ_IFR_ADDR_SA_LEN
3668 #define SIZEOF_IFREQ(sif) \
3669 ((sif)->ifr_addr.sa_len < sizeof (struct sockaddr) \
3670 ? sizeof (*(sif)) : sizeof ((sif)->ifr_name) + (sif)->ifr_addr.sa_len)
3672 int len
= SIZEOF_IFREQ (ifq
);
3674 int len
= sizeof (*ifreq
);
3676 char namebuf
[sizeof (ifq
->ifr_name
) + 1];
3678 ifreq
= (struct ifreq
*) ((char *) ifreq
+ len
);
3680 if (ifq
->ifr_addr
.sa_family
!= AF_INET
)
3683 memcpy (namebuf
, ifq
->ifr_name
, sizeof (ifq
->ifr_name
));
3684 namebuf
[sizeof (ifq
->ifr_name
)] = 0;
3685 res
= Fcons (Fcons (build_string (namebuf
),
3686 conv_sockaddr_to_lisp (&ifq
->ifr_addr
,
3687 sizeof (struct sockaddr
))),
3694 #endif /* SIOCGIFCONF */
3696 #if defined (SIOCGIFADDR) || defined (SIOCGIFHWADDR) || defined (SIOCGIFFLAGS)
3700 const char *flag_sym
;
3703 static const struct ifflag_def ifflag_table
[] = {
3707 #ifdef IFF_BROADCAST
3708 { IFF_BROADCAST
, "broadcast" },
3711 { IFF_DEBUG
, "debug" },
3714 { IFF_LOOPBACK
, "loopback" },
3716 #ifdef IFF_POINTOPOINT
3717 { IFF_POINTOPOINT
, "pointopoint" },
3720 { IFF_RUNNING
, "running" },
3723 { IFF_NOARP
, "noarp" },
3726 { IFF_PROMISC
, "promisc" },
3728 #ifdef IFF_NOTRAILERS
3729 #ifdef NS_IMPL_COCOA
3730 /* Really means smart, notrailers is obsolete */
3731 { IFF_NOTRAILERS
, "smart" },
3733 { IFF_NOTRAILERS
, "notrailers" },
3737 { IFF_ALLMULTI
, "allmulti" },
3740 { IFF_MASTER
, "master" },
3743 { IFF_SLAVE
, "slave" },
3745 #ifdef IFF_MULTICAST
3746 { IFF_MULTICAST
, "multicast" },
3749 { IFF_PORTSEL
, "portsel" },
3751 #ifdef IFF_AUTOMEDIA
3752 { IFF_AUTOMEDIA
, "automedia" },
3755 { IFF_DYNAMIC
, "dynamic" },
3758 { IFF_OACTIVE
, "oactive" }, /* OpenBSD: transmission in progress */
3761 { IFF_SIMPLEX
, "simplex" }, /* OpenBSD: can't hear own transmissions */
3764 { IFF_LINK0
, "link0" }, /* OpenBSD: per link layer defined bit */
3767 { IFF_LINK1
, "link1" }, /* OpenBSD: per link layer defined bit */
3770 { IFF_LINK2
, "link2" }, /* OpenBSD: per link layer defined bit */
3775 DEFUN ("network-interface-info", Fnetwork_interface_info
, Snetwork_interface_info
, 1, 1, 0,
3776 doc
: /* Return information about network interface named IFNAME.
3777 The return value is a list (ADDR BCAST NETMASK HWADDR FLAGS),
3778 where ADDR is the layer 3 address, BCAST is the layer 3 broadcast address,
3779 NETMASK is the layer 3 network mask, HWADDR is the layer 2 address, and
3780 FLAGS is the current flags of the interface. */)
3781 (Lisp_Object ifname
)
3784 Lisp_Object res
= Qnil
;
3788 #if (! (defined SIOCGIFHWADDR && defined HAVE_STRUCT_IFREQ_IFR_HWADDR) \
3789 && defined HAVE_GETIFADDRS && defined LLADDR)
3790 struct ifaddrs
*ifap
;
3793 CHECK_STRING (ifname
);
3795 if (sizeof rq
.ifr_name
<= SBYTES (ifname
))
3796 error ("interface name too long");
3797 strcpy (rq
.ifr_name
, SSDATA (ifname
));
3799 s
= socket (AF_INET
, SOCK_STREAM
, 0);
3804 #if defined (SIOCGIFFLAGS) && defined (HAVE_STRUCT_IFREQ_IFR_FLAGS)
3805 if (ioctl (s
, SIOCGIFFLAGS
, &rq
) == 0)
3807 int flags
= rq
.ifr_flags
;
3808 const struct ifflag_def
*fp
;
3811 /* If flags is smaller than int (i.e. short) it may have the high bit set
3812 due to IFF_MULTICAST. In that case, sign extending it into
3814 if (flags
< 0 && sizeof (rq
.ifr_flags
) < sizeof (flags
))
3815 flags
= (unsigned short) rq
.ifr_flags
;
3818 for (fp
= ifflag_table
; flags
!= 0 && fp
->flag_sym
; fp
++)
3820 if (flags
& fp
->flag_bit
)
3822 elt
= Fcons (intern (fp
->flag_sym
), elt
);
3823 flags
-= fp
->flag_bit
;
3826 for (fnum
= 0; flags
&& fnum
< 32; flags
>>= 1, fnum
++)
3830 elt
= Fcons (make_number (fnum
), elt
);
3835 res
= Fcons (elt
, res
);
3838 #if defined (SIOCGIFHWADDR) && defined (HAVE_STRUCT_IFREQ_IFR_HWADDR)
3839 if (ioctl (s
, SIOCGIFHWADDR
, &rq
) == 0)
3841 Lisp_Object hwaddr
= Fmake_vector (make_number (6), Qnil
);
3842 register struct Lisp_Vector
*p
= XVECTOR (hwaddr
);
3846 for (n
= 0; n
< 6; n
++)
3847 p
->contents
[n
] = make_number (((unsigned char *)&rq
.ifr_hwaddr
.sa_data
[0])[n
]);
3848 elt
= Fcons (make_number (rq
.ifr_hwaddr
.sa_family
), hwaddr
);
3850 #elif defined (HAVE_GETIFADDRS) && defined (LLADDR)
3851 if (getifaddrs (&ifap
) != -1)
3853 Lisp_Object hwaddr
= Fmake_vector (make_number (6), Qnil
);
3854 register struct Lisp_Vector
*p
= XVECTOR (hwaddr
);
3857 for (it
= ifap
; it
!= NULL
; it
= it
->ifa_next
)
3859 struct sockaddr_dl
*sdl
= (struct sockaddr_dl
*) it
->ifa_addr
;
3860 unsigned char linkaddr
[6];
3863 if (it
->ifa_addr
->sa_family
!= AF_LINK
3864 || strcmp (it
->ifa_name
, SSDATA (ifname
)) != 0
3865 || sdl
->sdl_alen
!= 6)
3868 memcpy (linkaddr
, LLADDR (sdl
), sdl
->sdl_alen
);
3869 for (n
= 0; n
< 6; n
++)
3870 p
->contents
[n
] = make_number (linkaddr
[n
]);
3872 elt
= Fcons (make_number (it
->ifa_addr
->sa_family
), hwaddr
);
3876 #ifdef HAVE_FREEIFADDRS
3880 #endif /* HAVE_GETIFADDRS && LLADDR */
3882 res
= Fcons (elt
, res
);
3885 #if defined (SIOCGIFNETMASK) && (defined (HAVE_STRUCT_IFREQ_IFR_NETMASK) || defined (HAVE_STRUCT_IFREQ_IFR_ADDR))
3886 if (ioctl (s
, SIOCGIFNETMASK
, &rq
) == 0)
3889 #ifdef HAVE_STRUCT_IFREQ_IFR_NETMASK
3890 elt
= conv_sockaddr_to_lisp (&rq
.ifr_netmask
, sizeof (rq
.ifr_netmask
));
3892 elt
= conv_sockaddr_to_lisp (&rq
.ifr_addr
, sizeof (rq
.ifr_addr
));
3896 res
= Fcons (elt
, res
);
3899 #if defined (SIOCGIFBRDADDR) && defined (HAVE_STRUCT_IFREQ_IFR_BROADADDR)
3900 if (ioctl (s
, SIOCGIFBRDADDR
, &rq
) == 0)
3903 elt
= conv_sockaddr_to_lisp (&rq
.ifr_broadaddr
, sizeof (rq
.ifr_broadaddr
));
3906 res
= Fcons (elt
, res
);
3909 #if defined (SIOCGIFADDR) && defined (HAVE_STRUCT_IFREQ_IFR_ADDR)
3910 if (ioctl (s
, SIOCGIFADDR
, &rq
) == 0)
3913 elt
= conv_sockaddr_to_lisp (&rq
.ifr_addr
, sizeof (rq
.ifr_addr
));
3916 res
= Fcons (elt
, res
);
3920 return any
? res
: Qnil
;
3923 #endif /* defined (HAVE_NET_IF_H) */
3925 /* Turn off input and output for process PROC. */
3928 deactivate_process (Lisp_Object proc
)
3930 register int inchannel
, outchannel
;
3931 register struct Lisp_Process
*p
= XPROCESS (proc
);
3934 /* Delete GnuTLS structures in PROC, if any. */
3935 emacs_gnutls_deinit (proc
);
3936 #endif /* HAVE_GNUTLS */
3938 inchannel
= p
->infd
;
3939 outchannel
= p
->outfd
;
3941 #ifdef ADAPTIVE_READ_BUFFERING
3942 if (p
->read_output_delay
> 0)
3944 if (--process_output_delay_count
< 0)
3945 process_output_delay_count
= 0;
3946 p
->read_output_delay
= 0;
3947 p
->read_output_skip
= 0;
3953 /* Beware SIGCHLD hereabouts. */
3954 flush_pending_output (inchannel
);
3955 emacs_close (inchannel
);
3956 if (outchannel
>= 0 && outchannel
!= inchannel
)
3957 emacs_close (outchannel
);
3961 #ifdef DATAGRAM_SOCKETS
3962 if (DATAGRAM_CHAN_P (inchannel
))
3964 xfree (datagram_address
[inchannel
].sa
);
3965 datagram_address
[inchannel
].sa
= 0;
3966 datagram_address
[inchannel
].len
= 0;
3969 chan_process
[inchannel
] = Qnil
;
3970 FD_CLR (inchannel
, &input_wait_mask
);
3971 FD_CLR (inchannel
, &non_keyboard_wait_mask
);
3972 #ifdef NON_BLOCKING_CONNECT
3973 if (FD_ISSET (inchannel
, &connect_wait_mask
))
3975 FD_CLR (inchannel
, &connect_wait_mask
);
3976 FD_CLR (inchannel
, &write_mask
);
3977 if (--num_pending_connects
< 0)
3981 if (inchannel
== max_process_desc
)
3984 /* We just closed the highest-numbered process input descriptor,
3985 so recompute the highest-numbered one now. */
3986 max_process_desc
= 0;
3987 for (i
= 0; i
< MAXDESC
; i
++)
3988 if (!NILP (chan_process
[i
]))
3989 max_process_desc
= i
;
3995 DEFUN ("accept-process-output", Faccept_process_output
, Saccept_process_output
,
3997 doc
: /* Allow any pending output from subprocesses to be read by Emacs.
3998 It is read into the process' buffers or given to their filter functions.
3999 Non-nil arg PROCESS means do not return until some output has been received
4002 Non-nil second arg SECONDS and third arg MILLISEC are number of seconds
4003 and milliseconds to wait; return after that much time whether or not
4004 there is any subprocess output. If SECONDS is a floating point number,
4005 it specifies a fractional number of seconds to wait.
4006 The MILLISEC argument is obsolete and should be avoided.
4008 If optional fourth arg JUST-THIS-ONE is non-nil, only accept output
4009 from PROCESS, suspending reading output from other processes.
4010 If JUST-THIS-ONE is an integer, don't run any timers either.
4011 Return non-nil if we received any output before the timeout expired. */)
4012 (register Lisp_Object process
, Lisp_Object seconds
, Lisp_Object millisec
, Lisp_Object just_this_one
)
4017 if (! NILP (process
))
4018 CHECK_PROCESS (process
);
4020 just_this_one
= Qnil
;
4022 if (!NILP (millisec
))
4023 { /* Obsolete calling convention using integers rather than floats. */
4024 CHECK_NUMBER (millisec
);
4026 seconds
= make_float (XINT (millisec
) / 1000.0);
4029 CHECK_NUMBER (seconds
);
4030 seconds
= make_float (XINT (millisec
) / 1000.0 + XINT (seconds
));
4037 if (!NILP (seconds
))
4039 if (INTEGERP (seconds
))
4041 if (0 < XINT (seconds
))
4043 secs
= XINT (seconds
);
4047 else if (FLOATP (seconds
))
4049 if (0 < XFLOAT_DATA (seconds
))
4051 EMACS_TIME t
= EMACS_TIME_FROM_DOUBLE (XFLOAT_DATA (seconds
));
4052 secs
= min (EMACS_SECS (t
), WAIT_READING_MAX
);
4053 nsecs
= EMACS_NSECS (t
);
4057 wrong_type_argument (Qnumberp
, seconds
);
4059 else if (! NILP (process
))
4063 (wait_reading_process_output (secs
, nsecs
, 0, 0,
4065 !NILP (process
) ? XPROCESS (process
) : NULL
,
4066 NILP (just_this_one
) ? 0 :
4067 !INTEGERP (just_this_one
) ? 1 : -1)
4071 /* Accept a connection for server process SERVER on CHANNEL. */
4073 static int connect_counter
= 0;
4076 server_accept_connection (Lisp_Object server
, int channel
)
4078 Lisp_Object proc
, caller
, name
, buffer
;
4079 Lisp_Object contact
, host
, service
;
4080 struct Lisp_Process
*ps
= XPROCESS (server
);
4081 struct Lisp_Process
*p
;
4085 struct sockaddr_in in
;
4087 struct sockaddr_in6 in6
;
4089 #ifdef HAVE_LOCAL_SOCKETS
4090 struct sockaddr_un un
;
4093 socklen_t len
= sizeof saddr
;
4095 s
= accept (channel
, &saddr
.sa
, &len
);
4104 if (code
== EWOULDBLOCK
)
4108 if (!NILP (ps
->log
))
4109 call3 (ps
->log
, server
, Qnil
,
4110 concat3 (build_string ("accept failed with code"),
4111 Fnumber_to_string (make_number (code
)),
4112 build_string ("\n")));
4118 /* Setup a new process to handle the connection. */
4120 /* Generate a unique identification of the caller, and build contact
4121 information for this process. */
4124 switch (saddr
.sa
.sa_family
)
4128 Lisp_Object args
[5];
4129 unsigned char *ip
= (unsigned char *)&saddr
.in
.sin_addr
.s_addr
;
4130 args
[0] = build_string ("%d.%d.%d.%d");
4131 args
[1] = make_number (*ip
++);
4132 args
[2] = make_number (*ip
++);
4133 args
[3] = make_number (*ip
++);
4134 args
[4] = make_number (*ip
++);
4135 host
= Fformat (5, args
);
4136 service
= make_number (ntohs (saddr
.in
.sin_port
));
4138 args
[0] = build_string (" <%s:%d>");
4141 caller
= Fformat (3, args
);
4148 Lisp_Object args
[9];
4149 uint16_t *ip6
= (uint16_t *)&saddr
.in6
.sin6_addr
;
4151 args
[0] = build_string ("%x:%x:%x:%x:%x:%x:%x:%x");
4152 for (i
= 0; i
< 8; i
++)
4153 args
[i
+1] = make_number (ntohs (ip6
[i
]));
4154 host
= Fformat (9, args
);
4155 service
= make_number (ntohs (saddr
.in
.sin_port
));
4157 args
[0] = build_string (" <[%s]:%d>");
4160 caller
= Fformat (3, args
);
4165 #ifdef HAVE_LOCAL_SOCKETS
4169 caller
= Fnumber_to_string (make_number (connect_counter
));
4170 caller
= concat3 (build_string (" <"), caller
, build_string (">"));
4174 /* Create a new buffer name for this process if it doesn't have a
4175 filter. The new buffer name is based on the buffer name or
4176 process name of the server process concatenated with the caller
4179 if (!NILP (ps
->filter
) && !EQ (ps
->filter
, Qt
))
4183 buffer
= ps
->buffer
;
4185 buffer
= Fbuffer_name (buffer
);
4190 buffer
= concat2 (buffer
, caller
);
4191 buffer
= Fget_buffer_create (buffer
);
4195 /* Generate a unique name for the new server process. Combine the
4196 server process name with the caller identification. */
4198 name
= concat2 (ps
->name
, caller
);
4199 proc
= make_process (name
);
4201 chan_process
[s
] = proc
;
4204 fcntl (s
, F_SETFL
, O_NONBLOCK
);
4207 fcntl (s
, F_SETFL
, O_NDELAY
);
4211 p
= XPROCESS (proc
);
4213 /* Build new contact information for this setup. */
4214 contact
= Fcopy_sequence (ps
->childp
);
4215 contact
= Fplist_put (contact
, QCserver
, Qnil
);
4216 contact
= Fplist_put (contact
, QChost
, host
);
4217 if (!NILP (service
))
4218 contact
= Fplist_put (contact
, QCservice
, service
);
4219 contact
= Fplist_put (contact
, QCremote
,
4220 conv_sockaddr_to_lisp (&saddr
.sa
, len
));
4221 #ifdef HAVE_GETSOCKNAME
4223 if (getsockname (s
, &saddr
.sa
, &len
) == 0)
4224 contact
= Fplist_put (contact
, QClocal
,
4225 conv_sockaddr_to_lisp (&saddr
.sa
, len
));
4228 pset_childp (p
, contact
);
4229 pset_plist (p
, Fcopy_sequence (ps
->plist
));
4230 pset_type (p
, Qnetwork
);
4232 pset_buffer (p
, buffer
);
4233 pset_sentinel (p
, ps
->sentinel
);
4234 pset_filter (p
, ps
->filter
);
4235 pset_command (p
, Qnil
);
4239 pset_status (p
, Qrun
);
4241 /* Client processes for accepted connections are not stopped initially. */
4242 if (!EQ (p
->filter
, Qt
))
4244 FD_SET (s
, &input_wait_mask
);
4245 FD_SET (s
, &non_keyboard_wait_mask
);
4248 if (s
> max_process_desc
)
4249 max_process_desc
= s
;
4251 /* Setup coding system for new process based on server process.
4252 This seems to be the proper thing to do, as the coding system
4253 of the new process should reflect the settings at the time the
4254 server socket was opened; not the current settings. */
4256 pset_decode_coding_system (p
, ps
->decode_coding_system
);
4257 pset_encode_coding_system (p
, ps
->encode_coding_system
);
4258 setup_process_coding_systems (proc
);
4260 pset_decoding_buf (p
, empty_unibyte_string
);
4261 p
->decoding_carryover
= 0;
4262 pset_encoding_buf (p
, empty_unibyte_string
);
4264 p
->inherit_coding_system_flag
4265 = (NILP (buffer
) ? 0 : ps
->inherit_coding_system_flag
);
4267 if (!NILP (ps
->log
))
4268 call3 (ps
->log
, server
, proc
,
4269 concat3 (build_string ("accept from "),
4270 (STRINGP (host
) ? host
: build_string ("-")),
4271 build_string ("\n")));
4273 if (!NILP (p
->sentinel
))
4274 exec_sentinel (proc
,
4275 concat3 (build_string ("open from "),
4276 (STRINGP (host
) ? host
: build_string ("-")),
4277 build_string ("\n")));
4280 /* This variable is different from waiting_for_input in keyboard.c.
4281 It is used to communicate to a lisp process-filter/sentinel (via the
4282 function Fwaiting_for_user_input_p below) whether Emacs was waiting
4283 for user-input when that process-filter was called.
4284 waiting_for_input cannot be used as that is by definition 0 when
4285 lisp code is being evalled.
4286 This is also used in record_asynch_buffer_change.
4287 For that purpose, this must be 0
4288 when not inside wait_reading_process_output. */
4289 static int waiting_for_user_input_p
;
4292 wait_reading_process_output_unwind (Lisp_Object data
)
4294 waiting_for_user_input_p
= XINT (data
);
4298 /* This is here so breakpoints can be put on it. */
4300 wait_reading_process_output_1 (void)
4304 /* Read and dispose of subprocess output while waiting for timeout to
4305 elapse and/or keyboard input to be available.
4309 If negative, gobble data immediately available but don't wait for any.
4312 an additional duration to wait, measured in nanoseconds
4313 If TIME_LIMIT is zero, then:
4314 If NSECS == 0, there is no limit.
4315 If NSECS > 0, the timeout consists of NSECS only.
4316 If NSECS < 0, gobble data immediately, as if TIME_LIMIT were negative.
4319 0 to ignore keyboard input, or
4320 1 to return when input is available, or
4321 -1 meaning caller will actually read the input, so don't throw to
4322 the quit handler, or
4324 DO_DISPLAY != 0 means redisplay should be done to show subprocess
4325 output that arrives.
4327 If WAIT_FOR_CELL is a cons cell, wait until its car is non-nil
4328 (and gobble terminal input into the buffer if any arrives).
4330 If WAIT_PROC is specified, wait until something arrives from that
4331 process. The return value is true if we read some input from
4334 If JUST_WAIT_PROC is non-nil, handle only output from WAIT_PROC
4335 (suspending output from other processes). A negative value
4336 means don't run any timers either.
4338 If WAIT_PROC is specified, then the function returns true if we
4339 received input from that process before the timeout elapsed.
4340 Otherwise, return true if we received input from any process. */
4343 wait_reading_process_output (intmax_t time_limit
, int nsecs
, int read_kbd
,
4345 Lisp_Object wait_for_cell
,
4346 struct Lisp_Process
*wait_proc
, int just_wait_proc
)
4348 register int channel
, nfds
;
4349 SELECT_TYPE Available
;
4350 SELECT_TYPE Writeok
;
4352 int check_delay
, no_avail
;
4355 EMACS_TIME timeout
, end_time
;
4356 int wait_channel
= -1;
4357 int got_some_input
= 0;
4358 ptrdiff_t count
= SPECPDL_INDEX ();
4360 FD_ZERO (&Available
);
4363 if (time_limit
== 0 && nsecs
== 0 && wait_proc
&& !NILP (Vinhibit_quit
)
4364 && !(CONSP (wait_proc
->status
)
4365 && EQ (XCAR (wait_proc
->status
), Qexit
)))
4366 message ("Blocking call to accept-process-output with quit inhibited!!");
4368 /* If wait_proc is a process to watch, set wait_channel accordingly. */
4369 if (wait_proc
!= NULL
)
4370 wait_channel
= wait_proc
->infd
;
4372 record_unwind_protect (wait_reading_process_output_unwind
,
4373 make_number (waiting_for_user_input_p
));
4374 waiting_for_user_input_p
= read_kbd
;
4381 else if (TYPE_MAXIMUM (time_t) < time_limit
)
4382 time_limit
= TYPE_MAXIMUM (time_t);
4384 /* Since we may need to wait several times,
4385 compute the absolute time to return at. */
4386 if (time_limit
|| 0 < nsecs
)
4388 timeout
= make_emacs_time (time_limit
, nsecs
);
4389 end_time
= add_emacs_time (current_emacs_time (), timeout
);
4394 int timeout_reduced_for_timers
= 0;
4396 /* If calling from keyboard input, do not quit
4397 since we want to return C-g as an input character.
4398 Otherwise, do pending quit if requested. */
4403 process_pending_signals ();
4406 /* Exit now if the cell we're waiting for became non-nil. */
4407 if (! NILP (wait_for_cell
) && ! NILP (XCAR (wait_for_cell
)))
4410 /* Compute time from now till when time limit is up */
4411 /* Exit if already run out */
4414 /* A negative timeout means
4415 gobble output available now
4416 but don't wait at all. */
4418 timeout
= make_emacs_time (0, 0);
4420 else if (time_limit
|| 0 < nsecs
)
4422 EMACS_TIME now
= current_emacs_time ();
4423 if (EMACS_TIME_LE (end_time
, now
))
4425 timeout
= sub_emacs_time (end_time
, now
);
4429 timeout
= make_emacs_time (100000, 0);
4432 /* Normally we run timers here.
4433 But not if wait_for_cell; in those cases,
4434 the wait is supposed to be short,
4435 and those callers cannot handle running arbitrary Lisp code here. */
4436 if (NILP (wait_for_cell
)
4437 && just_wait_proc
>= 0)
4439 EMACS_TIME timer_delay
;
4443 int old_timers_run
= timers_run
;
4444 struct buffer
*old_buffer
= current_buffer
;
4445 Lisp_Object old_window
= selected_window
;
4447 timer_delay
= timer_check ();
4449 /* If a timer has run, this might have changed buffers
4450 an alike. Make read_key_sequence aware of that. */
4451 if (timers_run
!= old_timers_run
4452 && (old_buffer
!= current_buffer
4453 || !EQ (old_window
, selected_window
))
4454 && waiting_for_user_input_p
== -1)
4455 record_asynch_buffer_change ();
4457 if (timers_run
!= old_timers_run
&& do_display
)
4458 /* We must retry, since a timer may have requeued itself
4459 and that could alter the time_delay. */
4460 redisplay_preserve_echo_area (9);
4464 while (!detect_input_pending ());
4466 /* If there is unread keyboard input, also return. */
4468 && requeued_events_pending_p ())
4471 /* A negative timeout means do not wait at all. */
4474 if (EMACS_TIME_VALID_P (timer_delay
))
4476 if (EMACS_TIME_LT (timer_delay
, timeout
))
4478 timeout
= timer_delay
;
4479 timeout_reduced_for_timers
= 1;
4484 /* This is so a breakpoint can be put here. */
4485 wait_reading_process_output_1 ();
4490 /* Cause C-g and alarm signals to take immediate action,
4491 and cause input available signals to zero out timeout.
4493 It is important that we do this before checking for process
4494 activity. If we get a SIGCHLD after the explicit checks for
4495 process activity, timeout is the only way we will know. */
4497 set_waiting_for_input (&timeout
);
4499 /* If status of something has changed, and no input is
4500 available, notify the user of the change right away. After
4501 this explicit check, we'll let the SIGCHLD handler zap
4502 timeout to get our attention. */
4503 if (update_tick
!= process_tick
)
4508 if (kbd_on_hold_p ())
4511 Atemp
= input_wait_mask
;
4514 timeout
= make_emacs_time (0, 0);
4515 if ((pselect (max (max_process_desc
, max_input_desc
) + 1,
4517 #ifdef NON_BLOCKING_CONNECT
4518 (num_pending_connects
> 0 ? &Ctemp
: NULL
),
4522 NULL
, &timeout
, NULL
)
4525 /* It's okay for us to do this and then continue with
4526 the loop, since timeout has already been zeroed out. */
4527 clear_waiting_for_input ();
4528 status_notify (NULL
);
4529 if (do_display
) redisplay_preserve_echo_area (13);
4533 /* Don't wait for output from a non-running process. Just
4534 read whatever data has already been received. */
4535 if (wait_proc
&& wait_proc
->raw_status_new
)
4536 update_status (wait_proc
);
4538 && ! EQ (wait_proc
->status
, Qrun
)
4539 && ! EQ (wait_proc
->status
, Qconnect
))
4541 int nread
, total_nread
= 0;
4543 clear_waiting_for_input ();
4544 XSETPROCESS (proc
, wait_proc
);
4546 /* Read data from the process, until we exhaust it. */
4547 while (wait_proc
->infd
>= 0)
4549 nread
= read_process_output (proc
, wait_proc
->infd
);
4556 total_nread
+= nread
;
4560 else if (nread
== -1 && EIO
== errno
)
4564 else if (nread
== -1 && EAGAIN
== errno
)
4568 else if (nread
== -1 && EWOULDBLOCK
== errno
)
4572 if (total_nread
> 0 && do_display
)
4573 redisplay_preserve_echo_area (10);
4578 /* Wait till there is something to do */
4580 if (wait_proc
&& just_wait_proc
)
4582 if (wait_proc
->infd
< 0) /* Terminated */
4584 FD_SET (wait_proc
->infd
, &Available
);
4588 else if (!NILP (wait_for_cell
))
4590 Available
= non_process_wait_mask
;
4597 Available
= non_keyboard_wait_mask
;
4599 Available
= input_wait_mask
;
4600 Writeok
= write_mask
;
4601 #ifdef SELECT_CANT_DO_WRITE_MASK
4606 check_delay
= wait_channel
>= 0 ? 0 : process_output_delay_count
;
4609 /* If frame size has changed or the window is newly mapped,
4610 redisplay now, before we start to wait. There is a race
4611 condition here; if a SIGIO arrives between now and the select
4612 and indicates that a frame is trashed, the select may block
4613 displaying a trashed screen. */
4614 if (frame_garbaged
&& do_display
)
4616 clear_waiting_for_input ();
4617 redisplay_preserve_echo_area (11);
4619 set_waiting_for_input (&timeout
);
4622 /* Skip the `select' call if input is available and we're
4623 waiting for keyboard input or a cell change (which can be
4624 triggered by processing X events). In the latter case, set
4625 nfds to 1 to avoid breaking the loop. */
4627 if ((read_kbd
|| !NILP (wait_for_cell
))
4628 && detect_input_pending ())
4630 nfds
= read_kbd
? 0 : 1;
4637 #ifdef ADAPTIVE_READ_BUFFERING
4638 /* Set the timeout for adaptive read buffering if any
4639 process has non-zero read_output_skip and non-zero
4640 read_output_delay, and we are not reading output for a
4641 specific wait_channel. It is not executed if
4642 Vprocess_adaptive_read_buffering is nil. */
4643 if (process_output_skip
&& check_delay
> 0)
4645 int nsecs
= EMACS_NSECS (timeout
);
4646 if (EMACS_SECS (timeout
) > 0 || nsecs
> READ_OUTPUT_DELAY_MAX
)
4647 nsecs
= READ_OUTPUT_DELAY_MAX
;
4648 for (channel
= 0; check_delay
> 0 && channel
<= max_process_desc
; channel
++)
4650 proc
= chan_process
[channel
];
4653 /* Find minimum non-zero read_output_delay among the
4654 processes with non-zero read_output_skip. */
4655 if (XPROCESS (proc
)->read_output_delay
> 0)
4658 if (!XPROCESS (proc
)->read_output_skip
)
4660 FD_CLR (channel
, &Available
);
4661 XPROCESS (proc
)->read_output_skip
= 0;
4662 if (XPROCESS (proc
)->read_output_delay
< nsecs
)
4663 nsecs
= XPROCESS (proc
)->read_output_delay
;
4666 timeout
= make_emacs_time (0, nsecs
);
4667 process_output_skip
= 0;
4670 #if defined (USE_GTK) || defined (HAVE_GCONF) || defined (HAVE_GSETTINGS)
4672 #elif defined (HAVE_NS)
4677 (max (max_process_desc
, max_input_desc
) + 1,
4679 (check_write
? &Writeok
: (SELECT_TYPE
*)0),
4680 NULL
, &timeout
, NULL
);
4683 /* GnuTLS buffers data internally. In lowat mode it leaves
4684 some data in the TCP buffers so that select works, but
4685 with custom pull/push functions we need to check if some
4686 data is available in the buffers manually. */
4691 /* We're not waiting on a specific process, so loop
4692 through all the channels and check for data.
4693 This is a workaround needed for some versions of
4694 the gnutls library -- 2.12.14 has been confirmed
4696 http://comments.gmane.org/gmane.emacs.devel/145074 */
4697 for (channel
= 0; channel
< MAXDESC
; ++channel
)
4698 if (! NILP (chan_process
[channel
]))
4700 struct Lisp_Process
*p
=
4701 XPROCESS (chan_process
[channel
]);
4702 if (p
&& p
->gnutls_p
&& p
->infd
4703 && ((emacs_gnutls_record_check_pending
4708 FD_SET (p
->infd
, &Available
);
4714 /* Check this specific channel. */
4715 if (wait_proc
->gnutls_p
/* Check for valid process. */
4716 /* Do we have pending data? */
4717 && ((emacs_gnutls_record_check_pending
4718 (wait_proc
->gnutls_state
))
4722 /* Set to Available. */
4723 FD_SET (wait_proc
->infd
, &Available
);
4732 /* Make C-g and alarm signals set flags again */
4733 clear_waiting_for_input ();
4735 /* If we woke up due to SIGWINCH, actually change size now. */
4736 do_pending_window_change (0);
4738 if ((time_limit
|| nsecs
) && nfds
== 0 && ! timeout_reduced_for_timers
)
4739 /* We waited the full specified time, so return now. */
4743 if (xerrno
== EINTR
)
4745 else if (xerrno
== EBADF
)
4748 /* AIX doesn't handle PTY closure the same way BSD does. On AIX,
4749 the child's closure of the pts gives the parent a SIGHUP, and
4750 the ptc file descriptor is automatically closed,
4751 yielding EBADF here or at select() call above.
4752 So, SIGHUP is ignored (see def of PTY_TTY_NAME_SPRINTF
4753 in m/ibmrt-aix.h), and here we just ignore the select error.
4754 Cleanup occurs c/o status_notify after SIGCLD. */
4755 no_avail
= 1; /* Cannot depend on values returned */
4761 error ("select error: %s", emacs_strerror (xerrno
));
4766 FD_ZERO (&Available
);
4770 #if 0 /* When polling is used, interrupt_input is 0,
4771 so get_input_pending should read the input.
4772 So this should not be needed. */
4773 /* If we are using polling for input,
4774 and we see input available, make it get read now.
4775 Otherwise it might not actually get read for a second.
4776 And on hpux, since we turn off polling in wait_reading_process_output,
4777 it might never get read at all if we don't spend much time
4778 outside of wait_reading_process_output. */
4779 if (read_kbd
&& interrupt_input
4780 && keyboard_bit_set (&Available
)
4781 && input_polling_used ())
4782 kill (getpid (), SIGALRM
);
4785 /* Check for keyboard input */
4786 /* If there is any, return immediately
4787 to give it higher priority than subprocesses */
4791 int old_timers_run
= timers_run
;
4792 struct buffer
*old_buffer
= current_buffer
;
4793 Lisp_Object old_window
= selected_window
;
4796 if (detect_input_pending_run_timers (do_display
))
4798 swallow_events (do_display
);
4799 if (detect_input_pending_run_timers (do_display
))
4803 /* If a timer has run, this might have changed buffers
4804 an alike. Make read_key_sequence aware of that. */
4805 if (timers_run
!= old_timers_run
4806 && waiting_for_user_input_p
== -1
4807 && (old_buffer
!= current_buffer
4808 || !EQ (old_window
, selected_window
)))
4809 record_asynch_buffer_change ();
4815 /* If there is unread keyboard input, also return. */
4817 && requeued_events_pending_p ())
4820 /* If we are not checking for keyboard input now,
4821 do process events (but don't run any timers).
4822 This is so that X events will be processed.
4823 Otherwise they may have to wait until polling takes place.
4824 That would causes delays in pasting selections, for example.
4826 (We used to do this only if wait_for_cell.) */
4827 if (read_kbd
== 0 && detect_input_pending ())
4829 swallow_events (do_display
);
4830 #if 0 /* Exiting when read_kbd doesn't request that seems wrong, though. */
4831 if (detect_input_pending ())
4836 /* Exit now if the cell we're waiting for became non-nil. */
4837 if (! NILP (wait_for_cell
) && ! NILP (XCAR (wait_for_cell
)))
4841 /* If we think we have keyboard input waiting, but didn't get SIGIO,
4842 go read it. This can happen with X on BSD after logging out.
4843 In that case, there really is no input and no SIGIO,
4844 but select says there is input. */
4846 if (read_kbd
&& interrupt_input
4847 && keyboard_bit_set (&Available
) && ! noninteractive
)
4848 kill (getpid (), SIGIO
);
4852 got_some_input
|= nfds
> 0;
4854 /* If checking input just got us a size-change event from X,
4855 obey it now if we should. */
4856 if (read_kbd
|| ! NILP (wait_for_cell
))
4857 do_pending_window_change (0);
4859 /* Check for data from a process. */
4860 if (no_avail
|| nfds
== 0)
4863 for (channel
= 0; channel
<= max_input_desc
; ++channel
)
4865 struct fd_callback_data
*d
= &fd_callback_info
[channel
];
4867 && ((d
->condition
& FOR_READ
4868 && FD_ISSET (channel
, &Available
))
4869 || (d
->condition
& FOR_WRITE
4870 && FD_ISSET (channel
, &write_mask
))))
4871 d
->func (channel
, d
->data
);
4874 for (channel
= 0; channel
<= max_process_desc
; channel
++)
4876 if (FD_ISSET (channel
, &Available
)
4877 && FD_ISSET (channel
, &non_keyboard_wait_mask
)
4878 && !FD_ISSET (channel
, &non_process_wait_mask
))
4882 /* If waiting for this channel, arrange to return as
4883 soon as no more input to be processed. No more
4885 if (wait_channel
== channel
)
4891 proc
= chan_process
[channel
];
4895 /* If this is a server stream socket, accept connection. */
4896 if (EQ (XPROCESS (proc
)->status
, Qlisten
))
4898 server_accept_connection (proc
, channel
);
4902 /* Read data from the process, starting with our
4903 buffered-ahead character if we have one. */
4905 nread
= read_process_output (proc
, channel
);
4908 /* Since read_process_output can run a filter,
4909 which can call accept-process-output,
4910 don't try to read from any other processes
4911 before doing the select again. */
4912 FD_ZERO (&Available
);
4915 redisplay_preserve_echo_area (12);
4918 else if (nread
== -1 && errno
== EWOULDBLOCK
)
4921 /* ISC 4.1 defines both EWOULDBLOCK and O_NONBLOCK,
4922 and Emacs uses O_NONBLOCK, so what we get is EAGAIN. */
4924 else if (nread
== -1 && errno
== EAGAIN
)
4928 else if (nread
== -1 && errno
== EAGAIN
)
4930 /* Note that we cannot distinguish between no input
4931 available now and a closed pipe.
4932 With luck, a closed pipe will be accompanied by
4933 subprocess termination and SIGCHLD. */
4934 else if (nread
== 0 && !NETCONN_P (proc
) && !SERIALCONN_P (proc
))
4936 #endif /* O_NDELAY */
4937 #endif /* O_NONBLOCK */
4939 /* On some OSs with ptys, when the process on one end of
4940 a pty exits, the other end gets an error reading with
4941 errno = EIO instead of getting an EOF (0 bytes read).
4942 Therefore, if we get an error reading and errno =
4943 EIO, just continue, because the child process has
4944 exited and should clean itself up soon (e.g. when we
4947 However, it has been known to happen that the SIGCHLD
4948 got lost. So raise the signal again just in case.
4950 else if (nread
== -1 && errno
== EIO
)
4952 struct Lisp_Process
*p
= XPROCESS (proc
);
4954 /* Clear the descriptor now, so we only raise the
4956 FD_CLR (channel
, &input_wait_mask
);
4957 FD_CLR (channel
, &non_keyboard_wait_mask
);
4961 /* If the EIO occurs on a pty, the SIGCHLD handler's
4962 waitpid call will not find the process object to
4963 delete. Do it here. */
4964 p
->tick
= ++process_tick
;
4965 pset_status (p
, Qfailed
);
4968 kill (getpid (), SIGCHLD
);
4970 #endif /* HAVE_PTYS */
4971 /* If we can detect process termination, don't consider the
4972 process gone just because its pipe is closed. */
4974 else if (nread
== 0 && !NETCONN_P (proc
) && !SERIALCONN_P (proc
))
4979 /* Preserve status of processes already terminated. */
4980 XPROCESS (proc
)->tick
= ++process_tick
;
4981 deactivate_process (proc
);
4982 if (XPROCESS (proc
)->raw_status_new
)
4983 update_status (XPROCESS (proc
));
4984 if (EQ (XPROCESS (proc
)->status
, Qrun
))
4985 pset_status (XPROCESS (proc
),
4986 list2 (Qexit
, make_number (256)));
4989 #ifdef NON_BLOCKING_CONNECT
4990 if (FD_ISSET (channel
, &Writeok
)
4991 && FD_ISSET (channel
, &connect_wait_mask
))
4993 struct Lisp_Process
*p
;
4995 FD_CLR (channel
, &connect_wait_mask
);
4996 FD_CLR (channel
, &write_mask
);
4997 if (--num_pending_connects
< 0)
5000 proc
= chan_process
[channel
];
5004 p
= XPROCESS (proc
);
5007 /* getsockopt(,,SO_ERROR,,) is said to hang on some systems.
5008 So only use it on systems where it is known to work. */
5010 socklen_t xlen
= sizeof (xerrno
);
5011 if (getsockopt (channel
, SOL_SOCKET
, SO_ERROR
, &xerrno
, &xlen
))
5016 struct sockaddr pname
;
5017 int pnamelen
= sizeof (pname
);
5019 /* If connection failed, getpeername will fail. */
5021 if (getpeername (channel
, &pname
, &pnamelen
) < 0)
5023 /* Obtain connect failure code through error slippage. */
5026 if (errno
== ENOTCONN
&& read (channel
, &dummy
, 1) < 0)
5033 p
->tick
= ++process_tick
;
5034 pset_status (p
, list2 (Qfailed
, make_number (xerrno
)));
5035 deactivate_process (proc
);
5039 pset_status (p
, Qrun
);
5040 /* Execute the sentinel here. If we had relied on
5041 status_notify to do it later, it will read input
5042 from the process before calling the sentinel. */
5043 exec_sentinel (proc
, build_string ("open\n"));
5044 if (!EQ (p
->filter
, Qt
) && !EQ (p
->command
, Qt
))
5046 FD_SET (p
->infd
, &input_wait_mask
);
5047 FD_SET (p
->infd
, &non_keyboard_wait_mask
);
5051 #endif /* NON_BLOCKING_CONNECT */
5052 } /* end for each file descriptor */
5053 } /* end while exit conditions not met */
5055 unbind_to (count
, Qnil
);
5057 /* If calling from keyboard input, do not quit
5058 since we want to return C-g as an input character.
5059 Otherwise, do pending quit if requested. */
5062 /* Prevent input_pending from remaining set if we quit. */
5063 clear_input_pending ();
5067 return got_some_input
;
5070 /* Given a list (FUNCTION ARGS...), apply FUNCTION to the ARGS. */
5073 read_process_output_call (Lisp_Object fun_and_args
)
5075 return apply1 (XCAR (fun_and_args
), XCDR (fun_and_args
));
5079 read_process_output_error_handler (Lisp_Object error_val
)
5081 cmd_error_internal (error_val
, "error in process filter: ");
5083 update_echo_area ();
5084 Fsleep_for (make_number (2), Qnil
);
5088 /* Read pending output from the process channel,
5089 starting with our buffered-ahead character if we have one.
5090 Yield number of decoded characters read.
5092 This function reads at most 4096 characters.
5093 If you want to read all available subprocess output,
5094 you must call it repeatedly until it returns zero.
5096 The characters read are decoded according to PROC's coding-system
5100 read_process_output (Lisp_Object proc
, register int channel
)
5102 register ssize_t nbytes
;
5104 register Lisp_Object outstream
;
5105 register struct Lisp_Process
*p
= XPROCESS (proc
);
5106 register ptrdiff_t opoint
;
5107 struct coding_system
*coding
= proc_decode_coding_system
[channel
];
5108 int carryover
= p
->decoding_carryover
;
5110 ptrdiff_t count
= SPECPDL_INDEX ();
5111 Lisp_Object odeactivate
;
5113 chars
= alloca (carryover
+ readmax
);
5115 /* See the comment above. */
5116 memcpy (chars
, SDATA (p
->decoding_buf
), carryover
);
5118 #ifdef DATAGRAM_SOCKETS
5119 /* We have a working select, so proc_buffered_char is always -1. */
5120 if (DATAGRAM_CHAN_P (channel
))
5122 socklen_t len
= datagram_address
[channel
].len
;
5123 nbytes
= recvfrom (channel
, chars
+ carryover
, readmax
,
5124 0, datagram_address
[channel
].sa
, &len
);
5129 int buffered
= 0 <= proc_buffered_char
[channel
];
5132 chars
[carryover
] = proc_buffered_char
[channel
];
5133 proc_buffered_char
[channel
] = -1;
5137 nbytes
= emacs_gnutls_read (p
, chars
+ carryover
+ buffered
,
5138 readmax
- buffered
);
5141 nbytes
= emacs_read (channel
, chars
+ carryover
+ buffered
,
5142 readmax
- buffered
);
5143 #ifdef ADAPTIVE_READ_BUFFERING
5144 if (nbytes
> 0 && p
->adaptive_read_buffering
)
5146 int delay
= p
->read_output_delay
;
5149 if (delay
< READ_OUTPUT_DELAY_MAX_MAX
)
5152 process_output_delay_count
++;
5153 delay
+= READ_OUTPUT_DELAY_INCREMENT
* 2;
5156 else if (delay
> 0 && nbytes
== readmax
- buffered
)
5158 delay
-= READ_OUTPUT_DELAY_INCREMENT
;
5160 process_output_delay_count
--;
5162 p
->read_output_delay
= delay
;
5165 p
->read_output_skip
= 1;
5166 process_output_skip
= 1;
5171 nbytes
+= buffered
&& nbytes
<= 0;
5174 p
->decoding_carryover
= 0;
5176 /* At this point, NBYTES holds number of bytes just received
5177 (including the one in proc_buffered_char[channel]). */
5180 if (nbytes
< 0 || coding
->mode
& CODING_MODE_LAST_BLOCK
)
5182 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
5185 /* Now set NBYTES how many bytes we must decode. */
5186 nbytes
+= carryover
;
5188 odeactivate
= Vdeactivate_mark
;
5189 /* There's no good reason to let process filters change the current
5190 buffer, and many callers of accept-process-output, sit-for, and
5191 friends don't expect current-buffer to be changed from under them. */
5192 record_unwind_current_buffer ();
5194 /* Read and dispose of the process output. */
5195 outstream
= p
->filter
;
5196 if (!NILP (outstream
))
5199 bool outer_running_asynch_code
= running_asynch_code
;
5200 int waiting
= waiting_for_user_input_p
;
5202 /* No need to gcpro these, because all we do with them later
5203 is test them for EQness, and none of them should be a string. */
5205 Lisp_Object obuffer
, okeymap
;
5206 XSETBUFFER (obuffer
, current_buffer
);
5207 okeymap
= BVAR (current_buffer
, keymap
);
5210 /* We inhibit quit here instead of just catching it so that
5211 hitting ^G when a filter happens to be running won't screw
5213 specbind (Qinhibit_quit
, Qt
);
5214 specbind (Qlast_nonmenu_event
, Qt
);
5216 /* In case we get recursively called,
5217 and we already saved the match data nonrecursively,
5218 save the same match data in safely recursive fashion. */
5219 if (outer_running_asynch_code
)
5222 /* Don't clobber the CURRENT match data, either! */
5223 tem
= Fmatch_data (Qnil
, Qnil
, Qnil
);
5224 restore_search_regs ();
5225 record_unwind_save_match_data ();
5226 Fset_match_data (tem
, Qt
);
5229 /* For speed, if a search happens within this code,
5230 save the match data in a special nonrecursive fashion. */
5231 running_asynch_code
= 1;
5233 decode_coding_c_string (coding
, (unsigned char *) chars
, nbytes
, Qt
);
5234 text
= coding
->dst_object
;
5235 Vlast_coding_system_used
= CODING_ID_NAME (coding
->id
);
5236 /* A new coding system might be found. */
5237 if (!EQ (p
->decode_coding_system
, Vlast_coding_system_used
))
5239 pset_decode_coding_system (p
, Vlast_coding_system_used
);
5241 /* Don't call setup_coding_system for
5242 proc_decode_coding_system[channel] here. It is done in
5243 detect_coding called via decode_coding above. */
5245 /* If a coding system for encoding is not yet decided, we set
5246 it as the same as coding-system for decoding.
5248 But, before doing that we must check if
5249 proc_encode_coding_system[p->outfd] surely points to a
5250 valid memory because p->outfd will be changed once EOF is
5251 sent to the process. */
5252 if (NILP (p
->encode_coding_system
)
5253 && proc_encode_coding_system
[p
->outfd
])
5255 pset_encode_coding_system
5256 (p
, coding_inherit_eol_type (Vlast_coding_system_used
, Qnil
));
5257 setup_coding_system (p
->encode_coding_system
,
5258 proc_encode_coding_system
[p
->outfd
]);
5262 if (coding
->carryover_bytes
> 0)
5264 if (SCHARS (p
->decoding_buf
) < coding
->carryover_bytes
)
5265 pset_decoding_buf (p
, make_uninit_string (coding
->carryover_bytes
));
5266 memcpy (SDATA (p
->decoding_buf
), coding
->carryover
,
5267 coding
->carryover_bytes
);
5268 p
->decoding_carryover
= coding
->carryover_bytes
;
5270 if (SBYTES (text
) > 0)
5271 /* FIXME: It's wrong to wrap or not based on debug-on-error, and
5272 sometimes it's simply wrong to wrap (e.g. when called from
5273 accept-process-output). */
5274 internal_condition_case_1 (read_process_output_call
,
5276 Fcons (proc
, Fcons (text
, Qnil
))),
5277 !NILP (Vdebug_on_error
) ? Qnil
: Qerror
,
5278 read_process_output_error_handler
);
5280 /* If we saved the match data nonrecursively, restore it now. */
5281 restore_search_regs ();
5282 running_asynch_code
= outer_running_asynch_code
;
5284 /* Restore waiting_for_user_input_p as it was
5285 when we were called, in case the filter clobbered it. */
5286 waiting_for_user_input_p
= waiting
;
5288 #if 0 /* Call record_asynch_buffer_change unconditionally,
5289 because we might have changed minor modes or other things
5290 that affect key bindings. */
5291 if (! EQ (Fcurrent_buffer (), obuffer
)
5292 || ! EQ (current_buffer
->keymap
, okeymap
))
5294 /* But do it only if the caller is actually going to read events.
5295 Otherwise there's no need to make him wake up, and it could
5296 cause trouble (for example it would make sit_for return). */
5297 if (waiting_for_user_input_p
== -1)
5298 record_asynch_buffer_change ();
5301 /* If no filter, write into buffer if it isn't dead. */
5302 else if (!NILP (p
->buffer
) && BUFFER_LIVE_P (XBUFFER (p
->buffer
)))
5304 Lisp_Object old_read_only
;
5305 ptrdiff_t old_begv
, old_zv
;
5306 ptrdiff_t old_begv_byte
, old_zv_byte
;
5307 ptrdiff_t before
, before_byte
;
5308 ptrdiff_t opoint_byte
;
5312 Fset_buffer (p
->buffer
);
5314 opoint_byte
= PT_BYTE
;
5315 old_read_only
= BVAR (current_buffer
, read_only
);
5318 old_begv_byte
= BEGV_BYTE
;
5319 old_zv_byte
= ZV_BYTE
;
5321 bset_read_only (current_buffer
, Qnil
);
5323 /* Insert new output into buffer
5324 at the current end-of-output marker,
5325 thus preserving logical ordering of input and output. */
5326 if (XMARKER (p
->mark
)->buffer
)
5327 SET_PT_BOTH (clip_to_bounds (BEGV
,
5328 marker_position (p
->mark
), ZV
),
5329 clip_to_bounds (BEGV_BYTE
,
5330 marker_byte_position (p
->mark
),
5333 SET_PT_BOTH (ZV
, ZV_BYTE
);
5335 before_byte
= PT_BYTE
;
5337 /* If the output marker is outside of the visible region, save
5338 the restriction and widen. */
5339 if (! (BEGV
<= PT
&& PT
<= ZV
))
5342 decode_coding_c_string (coding
, (unsigned char *) chars
, nbytes
, Qt
);
5343 text
= coding
->dst_object
;
5344 Vlast_coding_system_used
= CODING_ID_NAME (coding
->id
);
5345 /* A new coding system might be found. See the comment in the
5346 similar code in the previous `if' block. */
5347 if (!EQ (p
->decode_coding_system
, Vlast_coding_system_used
))
5349 pset_decode_coding_system (p
, Vlast_coding_system_used
);
5350 if (NILP (p
->encode_coding_system
)
5351 && proc_encode_coding_system
[p
->outfd
])
5353 pset_encode_coding_system
5354 (p
, coding_inherit_eol_type (Vlast_coding_system_used
, Qnil
));
5355 setup_coding_system (p
->encode_coding_system
,
5356 proc_encode_coding_system
[p
->outfd
]);
5359 if (coding
->carryover_bytes
> 0)
5361 if (SCHARS (p
->decoding_buf
) < coding
->carryover_bytes
)
5362 pset_decoding_buf (p
, make_uninit_string (coding
->carryover_bytes
));
5363 memcpy (SDATA (p
->decoding_buf
), coding
->carryover
,
5364 coding
->carryover_bytes
);
5365 p
->decoding_carryover
= coding
->carryover_bytes
;
5367 /* Adjust the multibyteness of TEXT to that of the buffer. */
5368 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
))
5369 != ! STRING_MULTIBYTE (text
))
5370 text
= (STRING_MULTIBYTE (text
)
5371 ? Fstring_as_unibyte (text
)
5372 : Fstring_to_multibyte (text
));
5373 /* Insert before markers in case we are inserting where
5374 the buffer's mark is, and the user's next command is Meta-y. */
5375 insert_from_string_before_markers (text
, 0, 0,
5376 SCHARS (text
), SBYTES (text
), 0);
5378 /* Make sure the process marker's position is valid when the
5379 process buffer is changed in the signal_after_change above.
5380 W3 is known to do that. */
5381 if (BUFFERP (p
->buffer
)
5382 && (b
= XBUFFER (p
->buffer
), b
!= current_buffer
))
5383 set_marker_both (p
->mark
, p
->buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
5385 set_marker_both (p
->mark
, p
->buffer
, PT
, PT_BYTE
);
5387 update_mode_lines
++;
5389 /* Make sure opoint and the old restrictions
5390 float ahead of any new text just as point would. */
5391 if (opoint
>= before
)
5393 opoint
+= PT
- before
;
5394 opoint_byte
+= PT_BYTE
- before_byte
;
5396 if (old_begv
> before
)
5398 old_begv
+= PT
- before
;
5399 old_begv_byte
+= PT_BYTE
- before_byte
;
5401 if (old_zv
>= before
)
5403 old_zv
+= PT
- before
;
5404 old_zv_byte
+= PT_BYTE
- before_byte
;
5407 /* If the restriction isn't what it should be, set it. */
5408 if (old_begv
!= BEGV
|| old_zv
!= ZV
)
5409 Fnarrow_to_region (make_number (old_begv
), make_number (old_zv
));
5412 bset_read_only (current_buffer
, old_read_only
);
5413 SET_PT_BOTH (opoint
, opoint_byte
);
5415 /* Handling the process output should not deactivate the mark. */
5416 Vdeactivate_mark
= odeactivate
;
5418 unbind_to (count
, Qnil
);
5422 /* Sending data to subprocess */
5424 static jmp_buf send_process_frame
;
5425 static Lisp_Object process_sent_to
;
5427 static _Noreturn
void
5428 handle_pipe_signal (int sig
)
5431 sigemptyset (&unblocked
);
5432 sigaddset (&unblocked
, SIGPIPE
);
5433 pthread_sigmask (SIG_UNBLOCK
, &unblocked
, 0);
5434 _longjmp (send_process_frame
, 1);
5438 deliver_pipe_signal (int sig
)
5440 handle_on_main_thread (sig
, handle_pipe_signal
);
5443 /* In send_process, when a write fails temporarily,
5444 wait_reading_process_output is called. It may execute user code,
5445 e.g. timers, that attempts to write new data to the same process.
5446 We must ensure that data is sent in the right order, and not
5447 interspersed half-completed with other writes (Bug#10815). This is
5448 handled by the write_queue element of struct process. It is a list
5449 with each entry having the form
5451 (string . (offset . length))
5453 where STRING is a lisp string, OFFSET is the offset into the
5454 string's byte sequence from which we should begin to send, and
5455 LENGTH is the number of bytes left to send. */
5457 /* Create a new entry in write_queue.
5458 INPUT_OBJ should be a buffer, string Qt, or Qnil.
5459 BUF is a pointer to the string sequence of the input_obj or a C
5460 string in case of Qt or Qnil. */
5463 write_queue_push (struct Lisp_Process
*p
, Lisp_Object input_obj
,
5464 const char *buf
, ptrdiff_t len
, int front
)
5467 Lisp_Object entry
, obj
;
5469 if (STRINGP (input_obj
))
5471 offset
= buf
- SSDATA (input_obj
);
5477 obj
= make_unibyte_string (buf
, len
);
5480 entry
= Fcons (obj
, Fcons (make_number (offset
), make_number (len
)));
5483 pset_write_queue (p
, Fcons (entry
, p
->write_queue
));
5485 pset_write_queue (p
, nconc2 (p
->write_queue
, Fcons (entry
, Qnil
)));
5488 /* Remove the first element in the write_queue of process P, put its
5489 contents in OBJ, BUF and LEN, and return non-zero. If the
5490 write_queue is empty, return zero. */
5493 write_queue_pop (struct Lisp_Process
*p
, Lisp_Object
*obj
,
5494 const char **buf
, ptrdiff_t *len
)
5496 Lisp_Object entry
, offset_length
;
5499 if (NILP (p
->write_queue
))
5502 entry
= XCAR (p
->write_queue
);
5503 pset_write_queue (p
, XCDR (p
->write_queue
));
5505 *obj
= XCAR (entry
);
5506 offset_length
= XCDR (entry
);
5508 *len
= XINT (XCDR (offset_length
));
5509 offset
= XINT (XCAR (offset_length
));
5510 *buf
= SSDATA (*obj
) + offset
;
5515 /* Send some data to process PROC.
5516 BUF is the beginning of the data; LEN is the number of characters.
5517 OBJECT is the Lisp object that the data comes from. If OBJECT is
5518 nil or t, it means that the data comes from C string.
5520 If OBJECT is not nil, the data is encoded by PROC's coding-system
5521 for encoding before it is sent.
5523 This function can evaluate Lisp code and can garbage collect. */
5526 send_process (volatile Lisp_Object proc
, const char *volatile buf
,
5527 volatile ptrdiff_t len
, volatile Lisp_Object object
)
5529 /* Use volatile to protect variables from being clobbered by longjmp. */
5530 struct Lisp_Process
*p
= XPROCESS (proc
);
5532 struct coding_system
*coding
;
5533 struct sigaction old_sigpipe_action
;
5535 if (p
->raw_status_new
)
5537 if (! EQ (p
->status
, Qrun
))
5538 error ("Process %s not running", SDATA (p
->name
));
5540 error ("Output file descriptor of %s is closed", SDATA (p
->name
));
5542 coding
= proc_encode_coding_system
[p
->outfd
];
5543 Vlast_coding_system_used
= CODING_ID_NAME (coding
->id
);
5545 if ((STRINGP (object
) && STRING_MULTIBYTE (object
))
5546 || (BUFFERP (object
)
5547 && !NILP (BVAR (XBUFFER (object
), enable_multibyte_characters
)))
5550 pset_encode_coding_system
5551 (p
, complement_process_encoding_system (p
->encode_coding_system
));
5552 if (!EQ (Vlast_coding_system_used
, p
->encode_coding_system
))
5554 /* The coding system for encoding was changed to raw-text
5555 because we sent a unibyte text previously. Now we are
5556 sending a multibyte text, thus we must encode it by the
5557 original coding system specified for the current process.
5559 Another reason we come here is that the coding system
5560 was just complemented and a new one was returned by
5561 complement_process_encoding_system. */
5562 setup_coding_system (p
->encode_coding_system
, coding
);
5563 Vlast_coding_system_used
= p
->encode_coding_system
;
5565 coding
->src_multibyte
= 1;
5569 coding
->src_multibyte
= 0;
5570 /* For sending a unibyte text, character code conversion should
5571 not take place but EOL conversion should. So, setup raw-text
5572 or one of the subsidiary if we have not yet done it. */
5573 if (CODING_REQUIRE_ENCODING (coding
))
5575 if (CODING_REQUIRE_FLUSHING (coding
))
5577 /* But, before changing the coding, we must flush out data. */
5578 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
5579 send_process (proc
, "", 0, Qt
);
5580 coding
->mode
&= CODING_MODE_LAST_BLOCK
;
5582 setup_coding_system (raw_text_coding_system
5583 (Vlast_coding_system_used
),
5585 coding
->src_multibyte
= 0;
5588 coding
->dst_multibyte
= 0;
5590 if (CODING_REQUIRE_ENCODING (coding
))
5592 coding
->dst_object
= Qt
;
5593 if (BUFFERP (object
))
5595 ptrdiff_t from_byte
, from
, to
;
5596 ptrdiff_t save_pt
, save_pt_byte
;
5597 struct buffer
*cur
= current_buffer
;
5599 set_buffer_internal (XBUFFER (object
));
5600 save_pt
= PT
, save_pt_byte
= PT_BYTE
;
5602 from_byte
= PTR_BYTE_POS ((unsigned char *) buf
);
5603 from
= BYTE_TO_CHAR (from_byte
);
5604 to
= BYTE_TO_CHAR (from_byte
+ len
);
5605 TEMP_SET_PT_BOTH (from
, from_byte
);
5606 encode_coding_object (coding
, object
, from
, from_byte
,
5607 to
, from_byte
+ len
, Qt
);
5608 TEMP_SET_PT_BOTH (save_pt
, save_pt_byte
);
5609 set_buffer_internal (cur
);
5611 else if (STRINGP (object
))
5613 encode_coding_object (coding
, object
, 0, 0, SCHARS (object
),
5614 SBYTES (object
), Qt
);
5618 coding
->dst_object
= make_unibyte_string (buf
, len
);
5619 coding
->produced
= len
;
5622 len
= coding
->produced
;
5623 object
= coding
->dst_object
;
5624 buf
= SSDATA (object
);
5627 if (pty_max_bytes
== 0)
5629 #if defined (HAVE_FPATHCONF) && defined (_PC_MAX_CANON)
5630 pty_max_bytes
= fpathconf (p
->outfd
, _PC_MAX_CANON
);
5631 if (pty_max_bytes
< 0)
5632 pty_max_bytes
= 250;
5634 pty_max_bytes
= 250;
5636 /* Deduct one, to leave space for the eof. */
5640 /* 2000-09-21: Emacs 20.7, sparc-sun-solaris-2.6, GCC 2.95.2,
5641 CFLAGS="-g -O": The value of the parameter `proc' is clobbered
5642 when returning with longjmp despite being declared volatile. */
5643 if (!_setjmp (send_process_frame
))
5645 p
= XPROCESS (proc
); /* Repair any setjmp clobbering. */
5646 process_sent_to
= proc
;
5648 /* If there is already data in the write_queue, put the new data
5649 in the back of queue. Otherwise, ignore it. */
5650 if (!NILP (p
->write_queue
))
5651 write_queue_push (p
, object
, buf
, len
, 0);
5653 do /* while !NILP (p->write_queue) */
5655 ptrdiff_t cur_len
= -1;
5656 const char *cur_buf
;
5657 Lisp_Object cur_object
;
5659 /* If write_queue is empty, ignore it. */
5660 if (!write_queue_pop (p
, &cur_object
, &cur_buf
, &cur_len
))
5664 cur_object
= object
;
5669 /* Send this batch, using one or more write calls. */
5670 ptrdiff_t written
= 0;
5671 int outfd
= p
->outfd
;
5672 struct sigaction action
;
5673 emacs_sigaction_init (&action
, deliver_pipe_signal
);
5674 sigaction (SIGPIPE
, &action
, &old_sigpipe_action
);
5675 #ifdef DATAGRAM_SOCKETS
5676 if (DATAGRAM_CHAN_P (outfd
))
5678 rv
= sendto (outfd
, cur_buf
, cur_len
,
5679 0, datagram_address
[outfd
].sa
,
5680 datagram_address
[outfd
].len
);
5683 else if (errno
== EMSGSIZE
)
5685 sigaction (SIGPIPE
, &old_sigpipe_action
, 0);
5686 report_file_error ("sending datagram",
5687 Fcons (proc
, Qnil
));
5695 written
= emacs_gnutls_write (p
, cur_buf
, cur_len
);
5698 written
= emacs_write (outfd
, cur_buf
, cur_len
);
5699 rv
= (written
? 0 : -1);
5700 #ifdef ADAPTIVE_READ_BUFFERING
5701 if (p
->read_output_delay
> 0
5702 && p
->adaptive_read_buffering
== 1)
5704 p
->read_output_delay
= 0;
5705 process_output_delay_count
--;
5706 p
->read_output_skip
= 0;
5710 sigaction (SIGPIPE
, &old_sigpipe_action
, 0);
5716 || errno
== EWOULDBLOCK
5722 /* Buffer is full. Wait, accepting input;
5723 that may allow the program
5724 to finish doing output and read more. */
5726 #ifdef BROKEN_PTY_READ_AFTER_EAGAIN
5727 /* A gross hack to work around a bug in FreeBSD.
5728 In the following sequence, read(2) returns
5732 write(2) 954 bytes, get EAGAIN
5733 read(2) 1024 bytes in process_read_output
5734 read(2) 11 bytes in process_read_output
5736 That is, read(2) returns more bytes than have
5737 ever been written successfully. The 1033 bytes
5738 read are the 1022 bytes written successfully
5739 after processing (for example with CRs added if
5740 the terminal is set up that way which it is
5741 here). The same bytes will be seen again in a
5742 later read(2), without the CRs. */
5744 if (errno
== EAGAIN
)
5747 ioctl (p
->outfd
, TIOCFLUSH
, &flags
);
5749 #endif /* BROKEN_PTY_READ_AFTER_EAGAIN */
5751 /* Put what we should have written in wait_queue. */
5752 write_queue_push (p
, cur_object
, cur_buf
, cur_len
, 1);
5753 wait_reading_process_output (0, 20 * 1000 * 1000,
5754 0, 0, Qnil
, NULL
, 0);
5755 /* Reread queue, to see what is left. */
5759 /* This is a real error. */
5760 report_file_error ("writing to process", Fcons (proc
, Qnil
));
5766 while (!NILP (p
->write_queue
));
5770 sigaction (SIGPIPE
, &old_sigpipe_action
, 0);
5771 proc
= process_sent_to
;
5772 p
= XPROCESS (proc
);
5773 p
->raw_status_new
= 0;
5774 pset_status (p
, Fcons (Qexit
, Fcons (make_number (256), Qnil
)));
5775 p
->tick
= ++process_tick
;
5776 deactivate_process (proc
);
5777 error ("SIGPIPE raised on process %s; closed it", SDATA (p
->name
));
5781 DEFUN ("process-send-region", Fprocess_send_region
, Sprocess_send_region
,
5783 doc
: /* Send current contents of region as input to PROCESS.
5784 PROCESS may be a process, a buffer, the name of a process or buffer, or
5785 nil, indicating the current buffer's process.
5786 Called from program, takes three arguments, PROCESS, START and END.
5787 If the region is more than 500 characters long,
5788 it is sent in several bunches. This may happen even for shorter regions.
5789 Output from processes can arrive in between bunches. */)
5790 (Lisp_Object process
, Lisp_Object start
, Lisp_Object end
)
5793 ptrdiff_t start1
, end1
;
5795 proc
= get_process (process
);
5796 validate_region (&start
, &end
);
5798 if (XINT (start
) < GPT
&& XINT (end
) > GPT
)
5799 move_gap (XINT (start
));
5801 start1
= CHAR_TO_BYTE (XINT (start
));
5802 end1
= CHAR_TO_BYTE (XINT (end
));
5803 send_process (proc
, (char *) BYTE_POS_ADDR (start1
), end1
- start1
,
5804 Fcurrent_buffer ());
5809 DEFUN ("process-send-string", Fprocess_send_string
, Sprocess_send_string
,
5811 doc
: /* Send PROCESS the contents of STRING as input.
5812 PROCESS may be a process, a buffer, the name of a process or buffer, or
5813 nil, indicating the current buffer's process.
5814 If STRING is more than 500 characters long,
5815 it is sent in several bunches. This may happen even for shorter strings.
5816 Output from processes can arrive in between bunches. */)
5817 (Lisp_Object process
, Lisp_Object string
)
5820 CHECK_STRING (string
);
5821 proc
= get_process (process
);
5822 send_process (proc
, SSDATA (string
),
5823 SBYTES (string
), string
);
5827 /* Return the foreground process group for the tty/pty that
5828 the process P uses. */
5830 emacs_get_tty_pgrp (struct Lisp_Process
*p
)
5835 if (ioctl (p
->infd
, TIOCGPGRP
, &gid
) == -1 && ! NILP (p
->tty_name
))
5838 /* Some OS:es (Solaris 8/9) does not allow TIOCGPGRP from the
5839 master side. Try the slave side. */
5840 fd
= emacs_open (SSDATA (p
->tty_name
), O_RDONLY
, 0);
5844 ioctl (fd
, TIOCGPGRP
, &gid
);
5848 #endif /* defined (TIOCGPGRP ) */
5853 DEFUN ("process-running-child-p", Fprocess_running_child_p
,
5854 Sprocess_running_child_p
, 0, 1, 0,
5855 doc
: /* Return t if PROCESS has given the terminal to a child.
5856 If the operating system does not make it possible to find out,
5857 return t unconditionally. */)
5858 (Lisp_Object process
)
5860 /* Initialize in case ioctl doesn't exist or gives an error,
5861 in a way that will cause returning t. */
5864 struct Lisp_Process
*p
;
5866 proc
= get_process (process
);
5867 p
= XPROCESS (proc
);
5869 if (!EQ (p
->type
, Qreal
))
5870 error ("Process %s is not a subprocess",
5873 error ("Process %s is not active",
5876 gid
= emacs_get_tty_pgrp (p
);
5883 /* send a signal number SIGNO to PROCESS.
5884 If CURRENT_GROUP is t, that means send to the process group
5885 that currently owns the terminal being used to communicate with PROCESS.
5886 This is used for various commands in shell mode.
5887 If CURRENT_GROUP is lambda, that means send to the process group
5888 that currently owns the terminal, but only if it is NOT the shell itself.
5890 If NOMSG is zero, insert signal-announcements into process's buffers
5893 If we can, we try to signal PROCESS by sending control characters
5894 down the pty. This allows us to signal inferiors who have changed
5895 their uid, for which killpg would return an EPERM error. */
5898 process_send_signal (Lisp_Object process
, int signo
, Lisp_Object current_group
,
5902 register struct Lisp_Process
*p
;
5906 proc
= get_process (process
);
5907 p
= XPROCESS (proc
);
5909 if (!EQ (p
->type
, Qreal
))
5910 error ("Process %s is not a subprocess",
5913 error ("Process %s is not active",
5917 current_group
= Qnil
;
5919 /* If we are using pgrps, get a pgrp number and make it negative. */
5920 if (NILP (current_group
))
5921 /* Send the signal to the shell's process group. */
5925 #ifdef SIGNALS_VIA_CHARACTERS
5926 /* If possible, send signals to the entire pgrp
5927 by sending an input character to it. */
5930 cc_t
*sig_char
= NULL
;
5932 tcgetattr (p
->infd
, &t
);
5937 sig_char
= &t
.c_cc
[VINTR
];
5941 sig_char
= &t
.c_cc
[VQUIT
];
5945 #if defined (VSWTCH) && !defined (PREFER_VSUSP)
5946 sig_char
= &t
.c_cc
[VSWTCH
];
5948 sig_char
= &t
.c_cc
[VSUSP
];
5953 if (sig_char
&& *sig_char
!= CDISABLE
)
5955 send_process (proc
, (char *) sig_char
, 1, Qnil
);
5958 /* If we can't send the signal with a character,
5959 fall through and send it another way. */
5961 /* The code above may fall through if it can't
5962 handle the signal. */
5963 #endif /* defined (SIGNALS_VIA_CHARACTERS) */
5966 /* Get the current pgrp using the tty itself, if we have that.
5967 Otherwise, use the pty to get the pgrp.
5968 On pfa systems, saka@pfu.fujitsu.co.JP writes:
5969 "TIOCGPGRP symbol defined in sys/ioctl.h at E50.
5970 But, TIOCGPGRP does not work on E50 ;-P works fine on E60"
5971 His patch indicates that if TIOCGPGRP returns an error, then
5972 we should just assume that p->pid is also the process group id. */
5974 gid
= emacs_get_tty_pgrp (p
);
5977 /* If we can't get the information, assume
5978 the shell owns the tty. */
5981 /* It is not clear whether anything really can set GID to -1.
5982 Perhaps on some system one of those ioctls can or could do so.
5983 Or perhaps this is vestigial. */
5986 #else /* ! defined (TIOCGPGRP ) */
5987 /* Can't select pgrps on this system, so we know that
5988 the child itself heads the pgrp. */
5990 #endif /* ! defined (TIOCGPGRP ) */
5992 /* If current_group is lambda, and the shell owns the terminal,
5993 don't send any signal. */
5994 if (EQ (current_group
, Qlambda
) && gid
== p
->pid
)
6002 p
->raw_status_new
= 0;
6003 pset_status (p
, Qrun
);
6004 p
->tick
= ++process_tick
;
6007 status_notify (NULL
);
6008 redisplay_preserve_echo_area (13);
6011 #endif /* ! defined (SIGCONT) */
6015 flush_pending_output (p
->infd
);
6019 /* If we don't have process groups, send the signal to the immediate
6020 subprocess. That isn't really right, but it's better than any
6021 obvious alternative. */
6024 kill (p
->pid
, signo
);
6028 /* gid may be a pid, or minus a pgrp's number */
6030 if (!NILP (current_group
))
6032 if (ioctl (p
->infd
, TIOCSIGSEND
, signo
) == -1)
6033 EMACS_KILLPG (gid
, signo
);
6040 #else /* ! defined (TIOCSIGSEND) */
6041 EMACS_KILLPG (gid
, signo
);
6042 #endif /* ! defined (TIOCSIGSEND) */
6045 DEFUN ("interrupt-process", Finterrupt_process
, Sinterrupt_process
, 0, 2, 0,
6046 doc
: /* Interrupt process PROCESS.
6047 PROCESS may be a process, a buffer, or the name of a process or buffer.
6048 No arg or nil means current buffer's process.
6049 Second arg CURRENT-GROUP non-nil means send signal to
6050 the current process-group of the process's controlling terminal
6051 rather than to the process's own process group.
6052 If the process is a shell, this means interrupt current subjob
6053 rather than the shell.
6055 If CURRENT-GROUP is `lambda', and if the shell owns the terminal,
6056 don't send the signal. */)
6057 (Lisp_Object process
, Lisp_Object current_group
)
6059 process_send_signal (process
, SIGINT
, current_group
, 0);
6063 DEFUN ("kill-process", Fkill_process
, Skill_process
, 0, 2, 0,
6064 doc
: /* Kill process PROCESS. May be process or name of one.
6065 See function `interrupt-process' for more details on usage. */)
6066 (Lisp_Object process
, Lisp_Object current_group
)
6068 process_send_signal (process
, SIGKILL
, current_group
, 0);
6072 DEFUN ("quit-process", Fquit_process
, Squit_process
, 0, 2, 0,
6073 doc
: /* Send QUIT signal to process PROCESS. May be process or name of one.
6074 See function `interrupt-process' for more details on usage. */)
6075 (Lisp_Object process
, Lisp_Object current_group
)
6077 process_send_signal (process
, SIGQUIT
, current_group
, 0);
6081 DEFUN ("stop-process", Fstop_process
, Sstop_process
, 0, 2, 0,
6082 doc
: /* Stop process PROCESS. May be process or name of one.
6083 See function `interrupt-process' for more details on usage.
6084 If PROCESS is a network or serial process, inhibit handling of incoming
6086 (Lisp_Object process
, Lisp_Object current_group
)
6088 if (PROCESSP (process
) && (NETCONN_P (process
) || SERIALCONN_P (process
)))
6090 struct Lisp_Process
*p
;
6092 p
= XPROCESS (process
);
6093 if (NILP (p
->command
)
6096 FD_CLR (p
->infd
, &input_wait_mask
);
6097 FD_CLR (p
->infd
, &non_keyboard_wait_mask
);
6099 pset_command (p
, Qt
);
6103 error ("No SIGTSTP support");
6105 process_send_signal (process
, SIGTSTP
, current_group
, 0);
6110 DEFUN ("continue-process", Fcontinue_process
, Scontinue_process
, 0, 2, 0,
6111 doc
: /* Continue process PROCESS. May be process or name of one.
6112 See function `interrupt-process' for more details on usage.
6113 If PROCESS is a network or serial process, resume handling of incoming
6115 (Lisp_Object process
, Lisp_Object current_group
)
6117 if (PROCESSP (process
) && (NETCONN_P (process
) || SERIALCONN_P (process
)))
6119 struct Lisp_Process
*p
;
6121 p
= XPROCESS (process
);
6122 if (EQ (p
->command
, Qt
)
6124 && (!EQ (p
->filter
, Qt
) || EQ (p
->status
, Qlisten
)))
6126 FD_SET (p
->infd
, &input_wait_mask
);
6127 FD_SET (p
->infd
, &non_keyboard_wait_mask
);
6129 if (fd_info
[ p
->infd
].flags
& FILE_SERIAL
)
6130 PurgeComm (fd_info
[ p
->infd
].hnd
, PURGE_RXABORT
| PURGE_RXCLEAR
);
6131 #else /* not WINDOWSNT */
6132 tcflush (p
->infd
, TCIFLUSH
);
6133 #endif /* not WINDOWSNT */
6135 pset_command (p
, Qnil
);
6139 process_send_signal (process
, SIGCONT
, current_group
, 0);
6141 error ("No SIGCONT support");
6146 DEFUN ("signal-process", Fsignal_process
, Ssignal_process
,
6147 2, 2, "sProcess (name or number): \nnSignal code: ",
6148 doc
: /* Send PROCESS the signal with code SIGCODE.
6149 PROCESS may also be a number specifying the process id of the
6150 process to signal; in this case, the process need not be a child of
6152 SIGCODE may be an integer, or a symbol whose name is a signal name. */)
6153 (Lisp_Object process
, Lisp_Object sigcode
)
6157 if (STRINGP (process
))
6159 Lisp_Object tem
= Fget_process (process
);
6162 Lisp_Object process_number
=
6163 string_to_number (SSDATA (process
), 10, 1);
6164 if (INTEGERP (process_number
) || FLOATP (process_number
))
6165 tem
= process_number
;
6169 else if (!NUMBERP (process
))
6170 process
= get_process (process
);
6175 if (NUMBERP (process
))
6176 CONS_TO_INTEGER (process
, pid_t
, pid
);
6179 CHECK_PROCESS (process
);
6180 pid
= XPROCESS (process
)->pid
;
6182 error ("Cannot signal process %s", SDATA (XPROCESS (process
)->name
));
6185 #define parse_signal(NAME, VALUE) \
6186 else if (!xstrcasecmp (name, NAME)) \
6187 XSETINT (sigcode, VALUE)
6189 if (INTEGERP (sigcode
))
6190 CHECK_TYPE_RANGED_INTEGER (int, sigcode
);
6195 CHECK_SYMBOL (sigcode
);
6196 name
= SSDATA (SYMBOL_NAME (sigcode
));
6198 if (!strncmp (name
, "SIG", 3) || !strncmp (name
, "sig", 3))
6204 parse_signal ("usr1", SIGUSR1
);
6207 parse_signal ("usr2", SIGUSR2
);
6210 parse_signal ("term", SIGTERM
);
6213 parse_signal ("hup", SIGHUP
);
6216 parse_signal ("int", SIGINT
);
6219 parse_signal ("quit", SIGQUIT
);
6222 parse_signal ("ill", SIGILL
);
6225 parse_signal ("abrt", SIGABRT
);
6228 parse_signal ("emt", SIGEMT
);
6231 parse_signal ("kill", SIGKILL
);
6234 parse_signal ("fpe", SIGFPE
);
6237 parse_signal ("bus", SIGBUS
);
6240 parse_signal ("segv", SIGSEGV
);
6243 parse_signal ("sys", SIGSYS
);
6246 parse_signal ("pipe", SIGPIPE
);
6249 parse_signal ("alrm", SIGALRM
);
6252 parse_signal ("urg", SIGURG
);
6255 parse_signal ("stop", SIGSTOP
);
6258 parse_signal ("tstp", SIGTSTP
);
6261 parse_signal ("cont", SIGCONT
);
6264 parse_signal ("chld", SIGCHLD
);
6267 parse_signal ("ttin", SIGTTIN
);
6270 parse_signal ("ttou", SIGTTOU
);
6273 parse_signal ("io", SIGIO
);
6276 parse_signal ("xcpu", SIGXCPU
);
6279 parse_signal ("xfsz", SIGXFSZ
);
6282 parse_signal ("vtalrm", SIGVTALRM
);
6285 parse_signal ("prof", SIGPROF
);
6288 parse_signal ("winch", SIGWINCH
);
6291 parse_signal ("info", SIGINFO
);
6294 error ("Undefined signal name %s", name
);
6299 return make_number (kill (pid
, XINT (sigcode
)));
6302 DEFUN ("process-send-eof", Fprocess_send_eof
, Sprocess_send_eof
, 0, 1, 0,
6303 doc
: /* Make PROCESS see end-of-file in its input.
6304 EOF comes after any text already sent to it.
6305 PROCESS may be a process, a buffer, the name of a process or buffer, or
6306 nil, indicating the current buffer's process.
6307 If PROCESS is a network connection, or is a process communicating
6308 through a pipe (as opposed to a pty), then you cannot send any more
6309 text to PROCESS after you call this function.
6310 If PROCESS is a serial process, wait until all output written to the
6311 process has been transmitted to the serial port. */)
6312 (Lisp_Object process
)
6315 struct coding_system
*coding
;
6317 if (DATAGRAM_CONN_P (process
))
6320 proc
= get_process (process
);
6321 coding
= proc_encode_coding_system
[XPROCESS (proc
)->outfd
];
6323 /* Make sure the process is really alive. */
6324 if (XPROCESS (proc
)->raw_status_new
)
6325 update_status (XPROCESS (proc
));
6326 if (! EQ (XPROCESS (proc
)->status
, Qrun
))
6327 error ("Process %s not running", SDATA (XPROCESS (proc
)->name
));
6329 if (CODING_REQUIRE_FLUSHING (coding
))
6331 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
6332 send_process (proc
, "", 0, Qnil
);
6335 if (XPROCESS (proc
)->pty_flag
)
6336 send_process (proc
, "\004", 1, Qnil
);
6337 else if (EQ (XPROCESS (proc
)->type
, Qserial
))
6340 if (tcdrain (XPROCESS (proc
)->outfd
) != 0)
6341 error ("tcdrain() failed: %s", emacs_strerror (errno
));
6342 #endif /* not WINDOWSNT */
6343 /* Do nothing on Windows because writes are blocking. */
6347 int old_outfd
, new_outfd
;
6349 #ifdef HAVE_SHUTDOWN
6350 /* If this is a network connection, or socketpair is used
6351 for communication with the subprocess, call shutdown to cause EOF.
6352 (In some old system, shutdown to socketpair doesn't work.
6353 Then we just can't win.) */
6354 if (EQ (XPROCESS (proc
)->type
, Qnetwork
)
6355 || XPROCESS (proc
)->outfd
== XPROCESS (proc
)->infd
)
6356 shutdown (XPROCESS (proc
)->outfd
, 1);
6357 /* In case of socketpair, outfd == infd, so don't close it. */
6358 if (XPROCESS (proc
)->outfd
!= XPROCESS (proc
)->infd
)
6359 emacs_close (XPROCESS (proc
)->outfd
);
6360 #else /* not HAVE_SHUTDOWN */
6361 emacs_close (XPROCESS (proc
)->outfd
);
6362 #endif /* not HAVE_SHUTDOWN */
6363 new_outfd
= emacs_open (NULL_DEVICE
, O_WRONLY
, 0);
6366 old_outfd
= XPROCESS (proc
)->outfd
;
6368 if (!proc_encode_coding_system
[new_outfd
])
6369 proc_encode_coding_system
[new_outfd
]
6370 = xmalloc (sizeof (struct coding_system
));
6371 *proc_encode_coding_system
[new_outfd
]
6372 = *proc_encode_coding_system
[old_outfd
];
6373 memset (proc_encode_coding_system
[old_outfd
], 0,
6374 sizeof (struct coding_system
));
6376 XPROCESS (proc
)->outfd
= new_outfd
;
6381 /* On receipt of a signal that a child status has changed, loop asking
6382 about children with changed statuses until the system says there
6385 All we do is change the status; we do not run sentinels or print
6386 notifications. That is saved for the next time keyboard input is
6387 done, in order to avoid timing errors.
6389 ** WARNING: this can be called during garbage collection.
6390 Therefore, it must not be fooled by the presence of mark bits in
6393 ** USG WARNING: Although it is not obvious from the documentation
6394 in signal(2), on a USG system the SIGCLD handler MUST NOT call
6395 signal() before executing at least one wait(), otherwise the
6396 handler will be called again, resulting in an infinite loop. The
6397 relevant portion of the documentation reads "SIGCLD signals will be
6398 queued and the signal-catching function will be continually
6399 reentered until the queue is empty". Invoking signal() causes the
6400 kernel to reexamine the SIGCLD queue. Fred Fish, UniSoft Systems
6403 ** Malloc WARNING: This should never call malloc either directly or
6404 indirectly; if it does, that is a bug */
6408 /* Record one child's changed status. Return true if a child was found. */
6410 record_child_status_change (void)
6413 struct Lisp_Process
*p
;
6419 pid
= waitpid (-1, &w
, WNOHANG
| WUNTRACED
);
6420 while (pid
< 0 && errno
== EINTR
);
6422 /* PID == 0 means no processes found, PID == -1 means a real failure.
6423 Either way, we have done all our job. */
6427 /* Find the process that signaled us, and record its status. */
6429 /* The process can have been deleted by Fdelete_process. */
6430 for (tail
= deleted_pid_list
; CONSP (tail
); tail
= XCDR (tail
))
6432 Lisp_Object xpid
= XCAR (tail
);
6433 if ((INTEGERP (xpid
) && pid
== XINT (xpid
))
6434 || (FLOATP (xpid
) && pid
== XFLOAT_DATA (xpid
)))
6436 XSETCAR (tail
, Qnil
);
6441 /* Otherwise, if it is asynchronous, it is in Vprocess_alist. */
6443 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
6445 proc
= XCDR (XCAR (tail
));
6446 p
= XPROCESS (proc
);
6447 if (EQ (p
->type
, Qreal
) && p
->pid
== pid
)
6452 /* Look for an asynchronous process whose pid hasn't been filled
6455 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
6457 proc
= XCDR (XCAR (tail
));
6458 p
= XPROCESS (proc
);
6464 /* Change the status of the process that was found. */
6467 int clear_desc_flag
= 0;
6469 p
->tick
= ++process_tick
;
6471 p
->raw_status_new
= 1;
6473 /* If process has terminated, stop waiting for its output. */
6474 if ((WIFSIGNALED (w
) || WIFEXITED (w
))
6476 clear_desc_flag
= 1;
6478 /* We use clear_desc_flag to avoid a compiler bug in Microsoft C. */
6479 if (clear_desc_flag
)
6481 FD_CLR (p
->infd
, &input_wait_mask
);
6482 FD_CLR (p
->infd
, &non_keyboard_wait_mask
);
6485 /* Tell wait_reading_process_output that it needs to wake up and
6487 if (input_available_clear_time
)
6488 *input_available_clear_time
= make_emacs_time (0, 0);
6490 /* There was no asynchronous process found for that pid: we have
6491 a synchronous process. */
6494 synch_process_alive
= 0;
6496 /* Report the status of the synchronous process. */
6498 synch_process_retcode
= WEXITSTATUS (w
);
6499 else if (WIFSIGNALED (w
))
6500 synch_process_termsig
= WTERMSIG (w
);
6502 /* Tell wait_reading_process_output that it needs to wake up and
6504 if (input_available_clear_time
)
6505 *input_available_clear_time
= make_emacs_time (0, 0);
6511 /* On some systems, the SIGCHLD handler must return right away. If
6512 any more processes want to signal us, we will get another signal.
6513 Otherwise, loop around to use up all the processes that have
6514 something to tell us. */
6515 #if (defined WINDOWSNT \
6516 || (defined USG && !defined GNU_LINUX \
6517 && !(defined HPUX && defined WNOHANG)))
6518 enum { CAN_HANDLE_MULTIPLE_CHILDREN
= 0 };
6520 enum { CAN_HANDLE_MULTIPLE_CHILDREN
= 1 };
6524 handle_child_signal (int sig
)
6526 while (record_child_status_change () && CAN_HANDLE_MULTIPLE_CHILDREN
)
6531 deliver_child_signal (int sig
)
6533 handle_on_main_thread (sig
, handle_child_signal
);
6536 #endif /* SIGCHLD */
6540 exec_sentinel_unwind (Lisp_Object data
)
6542 pset_sentinel (XPROCESS (XCAR (data
)), XCDR (data
));
6547 exec_sentinel_error_handler (Lisp_Object error_val
)
6549 cmd_error_internal (error_val
, "error in process sentinel: ");
6551 update_echo_area ();
6552 Fsleep_for (make_number (2), Qnil
);
6557 exec_sentinel (Lisp_Object proc
, Lisp_Object reason
)
6559 Lisp_Object sentinel
, odeactivate
;
6560 struct Lisp_Process
*p
= XPROCESS (proc
);
6561 ptrdiff_t count
= SPECPDL_INDEX ();
6562 bool outer_running_asynch_code
= running_asynch_code
;
6563 int waiting
= waiting_for_user_input_p
;
6565 if (inhibit_sentinels
)
6568 /* No need to gcpro these, because all we do with them later
6569 is test them for EQness, and none of them should be a string. */
6570 odeactivate
= Vdeactivate_mark
;
6572 Lisp_Object obuffer
, okeymap
;
6573 XSETBUFFER (obuffer
, current_buffer
);
6574 okeymap
= BVAR (current_buffer
, keymap
);
6577 /* There's no good reason to let sentinels change the current
6578 buffer, and many callers of accept-process-output, sit-for, and
6579 friends don't expect current-buffer to be changed from under them. */
6580 record_unwind_current_buffer ();
6582 sentinel
= p
->sentinel
;
6583 if (NILP (sentinel
))
6586 /* Zilch the sentinel while it's running, to avoid recursive invocations;
6587 assure that it gets restored no matter how the sentinel exits. */
6588 pset_sentinel (p
, Qnil
);
6589 record_unwind_protect (exec_sentinel_unwind
, Fcons (proc
, sentinel
));
6590 /* Inhibit quit so that random quits don't screw up a running filter. */
6591 specbind (Qinhibit_quit
, Qt
);
6592 specbind (Qlast_nonmenu_event
, Qt
); /* Why? --Stef */
6594 /* In case we get recursively called,
6595 and we already saved the match data nonrecursively,
6596 save the same match data in safely recursive fashion. */
6597 if (outer_running_asynch_code
)
6600 tem
= Fmatch_data (Qnil
, Qnil
, Qnil
);
6601 restore_search_regs ();
6602 record_unwind_save_match_data ();
6603 Fset_match_data (tem
, Qt
);
6606 /* For speed, if a search happens within this code,
6607 save the match data in a special nonrecursive fashion. */
6608 running_asynch_code
= 1;
6610 internal_condition_case_1 (read_process_output_call
,
6612 Fcons (proc
, Fcons (reason
, Qnil
))),
6613 !NILP (Vdebug_on_error
) ? Qnil
: Qerror
,
6614 exec_sentinel_error_handler
);
6616 /* If we saved the match data nonrecursively, restore it now. */
6617 restore_search_regs ();
6618 running_asynch_code
= outer_running_asynch_code
;
6620 Vdeactivate_mark
= odeactivate
;
6622 /* Restore waiting_for_user_input_p as it was
6623 when we were called, in case the filter clobbered it. */
6624 waiting_for_user_input_p
= waiting
;
6627 if (! EQ (Fcurrent_buffer (), obuffer
)
6628 || ! EQ (current_buffer
->keymap
, okeymap
))
6630 /* But do it only if the caller is actually going to read events.
6631 Otherwise there's no need to make him wake up, and it could
6632 cause trouble (for example it would make sit_for return). */
6633 if (waiting_for_user_input_p
== -1)
6634 record_asynch_buffer_change ();
6636 unbind_to (count
, Qnil
);
6639 /* Report all recent events of a change in process status
6640 (either run the sentinel or output a message).
6641 This is usually done while Emacs is waiting for keyboard input
6642 but can be done at other times. */
6645 status_notify (struct Lisp_Process
*deleting_process
)
6647 register Lisp_Object proc
, buffer
;
6648 Lisp_Object tail
, msg
;
6649 struct gcpro gcpro1
, gcpro2
;
6653 /* We need to gcpro tail; if read_process_output calls a filter
6654 which deletes a process and removes the cons to which tail points
6655 from Vprocess_alist, and then causes a GC, tail is an unprotected
6659 /* Set this now, so that if new processes are created by sentinels
6660 that we run, we get called again to handle their status changes. */
6661 update_tick
= process_tick
;
6663 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
6666 register struct Lisp_Process
*p
;
6668 proc
= Fcdr (XCAR (tail
));
6669 p
= XPROCESS (proc
);
6671 if (p
->tick
!= p
->update_tick
)
6673 p
->update_tick
= p
->tick
;
6675 /* If process is still active, read any output that remains. */
6676 while (! EQ (p
->filter
, Qt
)
6677 && ! EQ (p
->status
, Qconnect
)
6678 && ! EQ (p
->status
, Qlisten
)
6679 /* Network or serial process not stopped: */
6680 && ! EQ (p
->command
, Qt
)
6682 && p
!= deleting_process
6683 && read_process_output (proc
, p
->infd
) > 0);
6687 /* Get the text to use for the message. */
6688 if (p
->raw_status_new
)
6690 msg
= status_message (p
);
6692 /* If process is terminated, deactivate it or delete it. */
6694 if (CONSP (p
->status
))
6695 symbol
= XCAR (p
->status
);
6697 if (EQ (symbol
, Qsignal
) || EQ (symbol
, Qexit
)
6698 || EQ (symbol
, Qclosed
))
6700 if (delete_exited_processes
)
6701 remove_process (proc
);
6703 deactivate_process (proc
);
6706 /* The actions above may have further incremented p->tick.
6707 So set p->update_tick again
6708 so that an error in the sentinel will not cause
6709 this code to be run again. */
6710 p
->update_tick
= p
->tick
;
6711 /* Now output the message suitably. */
6712 if (!NILP (p
->sentinel
))
6713 exec_sentinel (proc
, msg
);
6714 /* Don't bother with a message in the buffer
6715 when a process becomes runnable. */
6716 else if (!EQ (symbol
, Qrun
) && !NILP (buffer
))
6719 struct buffer
*old
= current_buffer
;
6720 ptrdiff_t opoint
, opoint_byte
;
6721 ptrdiff_t before
, before_byte
;
6723 /* Avoid error if buffer is deleted
6724 (probably that's why the process is dead, too) */
6725 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
6727 Fset_buffer (buffer
);
6730 opoint_byte
= PT_BYTE
;
6731 /* Insert new output into buffer
6732 at the current end-of-output marker,
6733 thus preserving logical ordering of input and output. */
6734 if (XMARKER (p
->mark
)->buffer
)
6735 Fgoto_char (p
->mark
);
6737 SET_PT_BOTH (ZV
, ZV_BYTE
);
6740 before_byte
= PT_BYTE
;
6742 tem
= BVAR (current_buffer
, read_only
);
6743 bset_read_only (current_buffer
, Qnil
);
6744 insert_string ("\nProcess ");
6745 { /* FIXME: temporary kludge */
6746 Lisp_Object tem2
= p
->name
; Finsert (1, &tem2
); }
6747 insert_string (" ");
6749 bset_read_only (current_buffer
, tem
);
6750 set_marker_both (p
->mark
, p
->buffer
, PT
, PT_BYTE
);
6752 if (opoint
>= before
)
6753 SET_PT_BOTH (opoint
+ (PT
- before
),
6754 opoint_byte
+ (PT_BYTE
- before_byte
));
6756 SET_PT_BOTH (opoint
, opoint_byte
);
6758 set_buffer_internal (old
);
6763 update_mode_lines
++; /* in case buffers use %s in mode-line-format */
6768 DEFUN ("set-process-coding-system", Fset_process_coding_system
,
6769 Sset_process_coding_system
, 1, 3, 0,
6770 doc
: /* Set coding systems of PROCESS to DECODING and ENCODING.
6771 DECODING will be used to decode subprocess output and ENCODING to
6772 encode subprocess input. */)
6773 (register Lisp_Object process
, Lisp_Object decoding
, Lisp_Object encoding
)
6775 register struct Lisp_Process
*p
;
6777 CHECK_PROCESS (process
);
6778 p
= XPROCESS (process
);
6780 error ("Input file descriptor of %s closed", SDATA (p
->name
));
6782 error ("Output file descriptor of %s closed", SDATA (p
->name
));
6783 Fcheck_coding_system (decoding
);
6784 Fcheck_coding_system (encoding
);
6785 encoding
= coding_inherit_eol_type (encoding
, Qnil
);
6786 pset_decode_coding_system (p
, decoding
);
6787 pset_encode_coding_system (p
, encoding
);
6788 setup_process_coding_systems (process
);
6793 DEFUN ("process-coding-system",
6794 Fprocess_coding_system
, Sprocess_coding_system
, 1, 1, 0,
6795 doc
: /* Return a cons of coding systems for decoding and encoding of PROCESS. */)
6796 (register Lisp_Object process
)
6798 CHECK_PROCESS (process
);
6799 return Fcons (XPROCESS (process
)->decode_coding_system
,
6800 XPROCESS (process
)->encode_coding_system
);
6803 DEFUN ("set-process-filter-multibyte", Fset_process_filter_multibyte
,
6804 Sset_process_filter_multibyte
, 2, 2, 0,
6805 doc
: /* Set multibyteness of the strings given to PROCESS's filter.
6806 If FLAG is non-nil, the filter is given multibyte strings.
6807 If FLAG is nil, the filter is given unibyte strings. In this case,
6808 all character code conversion except for end-of-line conversion is
6810 (Lisp_Object process
, Lisp_Object flag
)
6812 register struct Lisp_Process
*p
;
6814 CHECK_PROCESS (process
);
6815 p
= XPROCESS (process
);
6817 pset_decode_coding_system
6818 (p
, raw_text_coding_system (p
->decode_coding_system
));
6819 setup_process_coding_systems (process
);
6824 DEFUN ("process-filter-multibyte-p", Fprocess_filter_multibyte_p
,
6825 Sprocess_filter_multibyte_p
, 1, 1, 0,
6826 doc
: /* Return t if a multibyte string is given to PROCESS's filter.*/)
6827 (Lisp_Object process
)
6829 register struct Lisp_Process
*p
;
6830 struct coding_system
*coding
;
6832 CHECK_PROCESS (process
);
6833 p
= XPROCESS (process
);
6834 coding
= proc_decode_coding_system
[p
->infd
];
6835 return (CODING_FOR_UNIBYTE (coding
) ? Qnil
: Qt
);
6844 add_gpm_wait_descriptor (int desc
)
6846 add_keyboard_wait_descriptor (desc
);
6850 delete_gpm_wait_descriptor (int desc
)
6852 delete_keyboard_wait_descriptor (desc
);
6857 # ifdef USABLE_SIGIO
6859 /* Return nonzero if *MASK has a bit set
6860 that corresponds to one of the keyboard input descriptors. */
6863 keyboard_bit_set (fd_set
*mask
)
6867 for (fd
= 0; fd
<= max_input_desc
; fd
++)
6868 if (FD_ISSET (fd
, mask
) && FD_ISSET (fd
, &input_wait_mask
)
6869 && !FD_ISSET (fd
, &non_keyboard_wait_mask
))
6876 #else /* not subprocesses */
6878 /* Defined on msdos.c. */
6879 extern int sys_select (int, SELECT_TYPE
*, SELECT_TYPE
*, SELECT_TYPE
*,
6880 EMACS_TIME
*, void *);
6882 /* Implementation of wait_reading_process_output, assuming that there
6883 are no subprocesses. Used only by the MS-DOS build.
6885 Wait for timeout to elapse and/or keyboard input to be available.
6889 If negative, gobble data immediately available but don't wait for any.
6892 an additional duration to wait, measured in nanoseconds
6893 If TIME_LIMIT is zero, then:
6894 If NSECS == 0, there is no limit.
6895 If NSECS > 0, the timeout consists of NSECS only.
6896 If NSECS < 0, gobble data immediately, as if TIME_LIMIT were negative.
6899 0 to ignore keyboard input, or
6900 1 to return when input is available, or
6901 -1 means caller will actually read the input, so don't throw to
6904 see full version for other parameters. We know that wait_proc will
6905 always be NULL, since `subprocesses' isn't defined.
6907 DO_DISPLAY != 0 means redisplay should be done to show subprocess
6908 output that arrives.
6910 Return true if we received input from any process. */
6913 wait_reading_process_output (intmax_t time_limit
, int nsecs
, int read_kbd
,
6915 Lisp_Object wait_for_cell
,
6916 struct Lisp_Process
*wait_proc
, int just_wait_proc
)
6919 EMACS_TIME end_time
, timeout
;
6926 else if (TYPE_MAXIMUM (time_t) < time_limit
)
6927 time_limit
= TYPE_MAXIMUM (time_t);
6929 /* What does time_limit really mean? */
6930 if (time_limit
|| 0 < nsecs
)
6932 timeout
= make_emacs_time (time_limit
, nsecs
);
6933 end_time
= add_emacs_time (current_emacs_time (), timeout
);
6936 /* Turn off periodic alarms (in case they are in use)
6937 and then turn off any other atimers,
6938 because the select emulator uses alarms. */
6940 turn_on_atimers (0);
6944 int timeout_reduced_for_timers
= 0;
6945 SELECT_TYPE waitchannels
;
6948 /* If calling from keyboard input, do not quit
6949 since we want to return C-g as an input character.
6950 Otherwise, do pending quit if requested. */
6954 /* Exit now if the cell we're waiting for became non-nil. */
6955 if (! NILP (wait_for_cell
) && ! NILP (XCAR (wait_for_cell
)))
6958 /* Compute time from now till when time limit is up */
6959 /* Exit if already run out */
6962 /* A negative timeout means
6963 gobble output available now
6964 but don't wait at all. */
6966 timeout
= make_emacs_time (0, 0);
6968 else if (time_limit
|| 0 < nsecs
)
6970 EMACS_TIME now
= current_emacs_time ();
6971 if (EMACS_TIME_LE (end_time
, now
))
6973 timeout
= sub_emacs_time (end_time
, now
);
6977 timeout
= make_emacs_time (100000, 0);
6980 /* If our caller will not immediately handle keyboard events,
6981 run timer events directly.
6982 (Callers that will immediately read keyboard events
6983 call timer_delay on their own.) */
6984 if (NILP (wait_for_cell
))
6986 EMACS_TIME timer_delay
;
6990 int old_timers_run
= timers_run
;
6991 timer_delay
= timer_check ();
6992 if (timers_run
!= old_timers_run
&& do_display
)
6993 /* We must retry, since a timer may have requeued itself
6994 and that could alter the time delay. */
6995 redisplay_preserve_echo_area (14);
6999 while (!detect_input_pending ());
7001 /* If there is unread keyboard input, also return. */
7003 && requeued_events_pending_p ())
7006 if (EMACS_TIME_VALID_P (timer_delay
) && 0 <= nsecs
)
7008 if (EMACS_TIME_LT (timer_delay
, timeout
))
7010 timeout
= timer_delay
;
7011 timeout_reduced_for_timers
= 1;
7016 /* Cause C-g and alarm signals to take immediate action,
7017 and cause input available signals to zero out timeout. */
7019 set_waiting_for_input (&timeout
);
7021 /* If a frame has been newly mapped and needs updating,
7022 reprocess its display stuff. */
7023 if (frame_garbaged
&& do_display
)
7025 clear_waiting_for_input ();
7026 redisplay_preserve_echo_area (15);
7028 set_waiting_for_input (&timeout
);
7031 /* Wait till there is something to do. */
7032 FD_ZERO (&waitchannels
);
7033 if (read_kbd
&& detect_input_pending ())
7037 if (read_kbd
|| !NILP (wait_for_cell
))
7038 FD_SET (0, &waitchannels
);
7039 nfds
= pselect (1, &waitchannels
, NULL
, NULL
, &timeout
, NULL
);
7044 /* Make C-g and alarm signals set flags again */
7045 clear_waiting_for_input ();
7047 /* If we woke up due to SIGWINCH, actually change size now. */
7048 do_pending_window_change (0);
7050 if ((time_limit
|| nsecs
) && nfds
== 0 && ! timeout_reduced_for_timers
)
7051 /* We waited the full specified time, so return now. */
7056 /* If the system call was interrupted, then go around the
7058 if (xerrno
== EINTR
)
7059 FD_ZERO (&waitchannels
);
7061 error ("select error: %s", emacs_strerror (xerrno
));
7064 /* Check for keyboard input */
7067 && detect_input_pending_run_timers (do_display
))
7069 swallow_events (do_display
);
7070 if (detect_input_pending_run_timers (do_display
))
7074 /* If there is unread keyboard input, also return. */
7076 && requeued_events_pending_p ())
7079 /* If wait_for_cell. check for keyboard input
7080 but don't run any timers.
7081 ??? (It seems wrong to me to check for keyboard
7082 input at all when wait_for_cell, but the code
7083 has been this way since July 1994.
7084 Try changing this after version 19.31.) */
7085 if (! NILP (wait_for_cell
)
7086 && detect_input_pending ())
7088 swallow_events (do_display
);
7089 if (detect_input_pending ())
7093 /* Exit now if the cell we're waiting for became non-nil. */
7094 if (! NILP (wait_for_cell
) && ! NILP (XCAR (wait_for_cell
)))
7103 #endif /* not subprocesses */
7105 /* The following functions are needed even if async subprocesses are
7106 not supported. Some of them are no-op stubs in that case. */
7108 /* Add DESC to the set of keyboard input descriptors. */
7111 add_keyboard_wait_descriptor (int desc
)
7113 #ifdef subprocesses /* actually means "not MSDOS" */
7114 FD_SET (desc
, &input_wait_mask
);
7115 FD_SET (desc
, &non_process_wait_mask
);
7116 if (desc
> max_input_desc
)
7117 max_input_desc
= desc
;
7121 /* From now on, do not expect DESC to give keyboard input. */
7124 delete_keyboard_wait_descriptor (int desc
)
7128 int lim
= max_input_desc
;
7130 FD_CLR (desc
, &input_wait_mask
);
7131 FD_CLR (desc
, &non_process_wait_mask
);
7133 if (desc
== max_input_desc
)
7134 for (fd
= 0; fd
< lim
; fd
++)
7135 if (FD_ISSET (fd
, &input_wait_mask
) || FD_ISSET (fd
, &write_mask
))
7136 max_input_desc
= fd
;
7140 /* Setup coding systems of PROCESS. */
7143 setup_process_coding_systems (Lisp_Object process
)
7146 struct Lisp_Process
*p
= XPROCESS (process
);
7148 int outch
= p
->outfd
;
7149 Lisp_Object coding_system
;
7151 if (inch
< 0 || outch
< 0)
7154 if (!proc_decode_coding_system
[inch
])
7155 proc_decode_coding_system
[inch
] = xmalloc (sizeof (struct coding_system
));
7156 coding_system
= p
->decode_coding_system
;
7157 if (! NILP (p
->filter
))
7159 else if (BUFFERP (p
->buffer
))
7161 if (NILP (BVAR (XBUFFER (p
->buffer
), enable_multibyte_characters
)))
7162 coding_system
= raw_text_coding_system (coding_system
);
7164 setup_coding_system (coding_system
, proc_decode_coding_system
[inch
]);
7166 if (!proc_encode_coding_system
[outch
])
7167 proc_encode_coding_system
[outch
] = xmalloc (sizeof (struct coding_system
));
7168 setup_coding_system (p
->encode_coding_system
,
7169 proc_encode_coding_system
[outch
]);
7173 /* Close all descriptors currently in use for communication
7174 with subprocess. This is used in a newly-forked subprocess
7175 to get rid of irrelevant descriptors. */
7178 close_process_descs (void)
7182 for (i
= 0; i
< MAXDESC
; i
++)
7184 Lisp_Object process
;
7185 process
= chan_process
[i
];
7186 if (!NILP (process
))
7188 int in
= XPROCESS (process
)->infd
;
7189 int out
= XPROCESS (process
)->outfd
;
7192 if (out
>= 0 && in
!= out
)
7199 DEFUN ("get-buffer-process", Fget_buffer_process
, Sget_buffer_process
, 1, 1, 0,
7200 doc
: /* Return the (or a) process associated with BUFFER.
7201 BUFFER may be a buffer or the name of one. */)
7202 (register Lisp_Object buffer
)
7205 register Lisp_Object buf
, tail
, proc
;
7207 if (NILP (buffer
)) return Qnil
;
7208 buf
= Fget_buffer (buffer
);
7209 if (NILP (buf
)) return Qnil
;
7211 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
7213 proc
= Fcdr (XCAR (tail
));
7214 if (PROCESSP (proc
) && EQ (XPROCESS (proc
)->buffer
, buf
))
7217 #endif /* subprocesses */
7221 DEFUN ("process-inherit-coding-system-flag",
7222 Fprocess_inherit_coding_system_flag
, Sprocess_inherit_coding_system_flag
,
7224 doc
: /* Return the value of inherit-coding-system flag for PROCESS.
7225 If this flag is t, `buffer-file-coding-system' of the buffer
7226 associated with PROCESS will inherit the coding system used to decode
7227 the process output. */)
7228 (register Lisp_Object process
)
7231 CHECK_PROCESS (process
);
7232 return XPROCESS (process
)->inherit_coding_system_flag
? Qt
: Qnil
;
7234 /* Ignore the argument and return the value of
7235 inherit-process-coding-system. */
7236 return inherit_process_coding_system
? Qt
: Qnil
;
7240 /* Kill all processes associated with `buffer'.
7241 If `buffer' is nil, kill all processes */
7244 kill_buffer_processes (Lisp_Object buffer
)
7247 Lisp_Object tail
, proc
;
7249 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
7251 proc
= XCDR (XCAR (tail
));
7253 && (NILP (buffer
) || EQ (XPROCESS (proc
)->buffer
, buffer
)))
7255 if (NETCONN_P (proc
) || SERIALCONN_P (proc
))
7256 Fdelete_process (proc
);
7257 else if (XPROCESS (proc
)->infd
>= 0)
7258 process_send_signal (proc
, SIGHUP
, Qnil
, 1);
7261 #else /* subprocesses */
7262 /* Since we have no subprocesses, this does nothing. */
7263 #endif /* subprocesses */
7266 DEFUN ("waiting-for-user-input-p", Fwaiting_for_user_input_p
,
7267 Swaiting_for_user_input_p
, 0, 0, 0,
7268 doc
: /* Returns non-nil if Emacs is waiting for input from the user.
7269 This is intended for use by asynchronous process output filters and sentinels. */)
7273 return (waiting_for_user_input_p
? Qt
: Qnil
);
7279 /* Stop reading input from keyboard sources. */
7282 hold_keyboard_input (void)
7287 /* Resume reading input from keyboard sources. */
7290 unhold_keyboard_input (void)
7295 /* Return non-zero if keyboard input is on hold, zero otherwise. */
7298 kbd_on_hold_p (void)
7300 return kbd_is_on_hold
;
7304 /* Enumeration of and access to system processes a-la ps(1). */
7306 DEFUN ("list-system-processes", Flist_system_processes
, Slist_system_processes
,
7308 doc
: /* Return a list of numerical process IDs of all running processes.
7309 If this functionality is unsupported, return nil.
7311 See `process-attributes' for getting attributes of a process given its ID. */)
7314 return list_system_processes ();
7317 DEFUN ("process-attributes", Fprocess_attributes
,
7318 Sprocess_attributes
, 1, 1, 0,
7319 doc
: /* Return attributes of the process given by its PID, a number.
7321 Value is an alist where each element is a cons cell of the form
7325 If this functionality is unsupported, the value is nil.
7327 See `list-system-processes' for getting a list of all process IDs.
7329 The KEYs of the attributes that this function may return are listed
7330 below, together with the type of the associated VALUE (in parentheses).
7331 Not all platforms support all of these attributes; unsupported
7332 attributes will not appear in the returned alist.
7333 Unless explicitly indicated otherwise, numbers can have either
7334 integer or floating point values.
7336 euid -- Effective user User ID of the process (number)
7337 user -- User name corresponding to euid (string)
7338 egid -- Effective user Group ID of the process (number)
7339 group -- Group name corresponding to egid (string)
7340 comm -- Command name (executable name only) (string)
7341 state -- Process state code, such as "S", "R", or "T" (string)
7342 ppid -- Parent process ID (number)
7343 pgrp -- Process group ID (number)
7344 sess -- Session ID, i.e. process ID of session leader (number)
7345 ttname -- Controlling tty name (string)
7346 tpgid -- ID of foreground process group on the process's tty (number)
7347 minflt -- number of minor page faults (number)
7348 majflt -- number of major page faults (number)
7349 cminflt -- cumulative number of minor page faults (number)
7350 cmajflt -- cumulative number of major page faults (number)
7351 utime -- user time used by the process, in (current-time) format,
7352 which is a list of integers (HIGH LOW USEC PSEC)
7353 stime -- system time used by the process (current-time)
7354 time -- sum of utime and stime (current-time)
7355 cutime -- user time used by the process and its children (current-time)
7356 cstime -- system time used by the process and its children (current-time)
7357 ctime -- sum of cutime and cstime (current-time)
7358 pri -- priority of the process (number)
7359 nice -- nice value of the process (number)
7360 thcount -- process thread count (number)
7361 start -- time the process started (current-time)
7362 vsize -- virtual memory size of the process in KB's (number)
7363 rss -- resident set size of the process in KB's (number)
7364 etime -- elapsed time the process is running, in (HIGH LOW USEC PSEC) format
7365 pcpu -- percents of CPU time used by the process (floating-point number)
7366 pmem -- percents of total physical memory used by process's resident set
7367 (floating-point number)
7368 args -- command line which invoked the process (string). */)
7371 return system_process_attributes (pid
);
7375 /* This is not called "init_process" because that is the name of a
7376 Mach system call, so it would cause problems on Darwin systems. */
7378 init_process_emacs (void)
7383 inhibit_sentinels
= 0;
7387 if (! noninteractive
|| initialized
)
7390 struct sigaction action
;
7391 emacs_sigaction_init (&action
, deliver_child_signal
);
7392 sigaction (SIGCHLD
, &action
, 0);
7396 FD_ZERO (&input_wait_mask
);
7397 FD_ZERO (&non_keyboard_wait_mask
);
7398 FD_ZERO (&non_process_wait_mask
);
7399 FD_ZERO (&write_mask
);
7400 max_process_desc
= 0;
7401 memset (fd_callback_info
, 0, sizeof (fd_callback_info
));
7403 #ifdef NON_BLOCKING_CONNECT
7404 FD_ZERO (&connect_wait_mask
);
7405 num_pending_connects
= 0;
7408 #ifdef ADAPTIVE_READ_BUFFERING
7409 process_output_delay_count
= 0;
7410 process_output_skip
= 0;
7413 /* Don't do this, it caused infinite select loops. The display
7414 method should call add_keyboard_wait_descriptor on stdin if it
7417 FD_SET (0, &input_wait_mask
);
7420 Vprocess_alist
= Qnil
;
7422 deleted_pid_list
= Qnil
;
7424 for (i
= 0; i
< MAXDESC
; i
++)
7426 chan_process
[i
] = Qnil
;
7427 proc_buffered_char
[i
] = -1;
7429 memset (proc_decode_coding_system
, 0, sizeof proc_decode_coding_system
);
7430 memset (proc_encode_coding_system
, 0, sizeof proc_encode_coding_system
);
7431 #ifdef DATAGRAM_SOCKETS
7432 memset (datagram_address
, 0, sizeof datagram_address
);
7436 Lisp_Object subfeatures
= Qnil
;
7437 const struct socket_options
*sopt
;
7439 #define ADD_SUBFEATURE(key, val) \
7440 subfeatures = pure_cons (pure_cons (key, pure_cons (val, Qnil)), subfeatures)
7442 #ifdef NON_BLOCKING_CONNECT
7443 ADD_SUBFEATURE (QCnowait
, Qt
);
7445 #ifdef DATAGRAM_SOCKETS
7446 ADD_SUBFEATURE (QCtype
, Qdatagram
);
7448 #ifdef HAVE_SEQPACKET
7449 ADD_SUBFEATURE (QCtype
, Qseqpacket
);
7451 #ifdef HAVE_LOCAL_SOCKETS
7452 ADD_SUBFEATURE (QCfamily
, Qlocal
);
7454 ADD_SUBFEATURE (QCfamily
, Qipv4
);
7456 ADD_SUBFEATURE (QCfamily
, Qipv6
);
7458 #ifdef HAVE_GETSOCKNAME
7459 ADD_SUBFEATURE (QCservice
, Qt
);
7461 #if defined (O_NONBLOCK) || defined (O_NDELAY)
7462 ADD_SUBFEATURE (QCserver
, Qt
);
7465 for (sopt
= socket_options
; sopt
->name
; sopt
++)
7466 subfeatures
= pure_cons (intern_c_string (sopt
->name
), subfeatures
);
7468 Fprovide (intern_c_string ("make-network-process"), subfeatures
);
7471 #if defined (DARWIN_OS)
7472 /* PTYs are broken on Darwin < 6, but are sometimes useful for interactive
7473 processes. As such, we only change the default value. */
7476 char const *release
= (STRINGP (Voperating_system_release
)
7477 ? SSDATA (Voperating_system_release
)
7479 if (!release
|| !release
[0] || (release
[0] < '7' && release
[1] == '.')) {
7480 Vprocess_connection_type
= Qnil
;
7484 #endif /* subprocesses */
7489 syms_of_process (void)
7493 DEFSYM (Qprocessp
, "processp");
7494 DEFSYM (Qrun
, "run");
7495 DEFSYM (Qstop
, "stop");
7496 DEFSYM (Qsignal
, "signal");
7498 /* Qexit is already staticpro'd by syms_of_eval; don't staticpro it
7501 Qexit = intern_c_string ("exit");
7502 staticpro (&Qexit); */
7504 DEFSYM (Qopen
, "open");
7505 DEFSYM (Qclosed
, "closed");
7506 DEFSYM (Qconnect
, "connect");
7507 DEFSYM (Qfailed
, "failed");
7508 DEFSYM (Qlisten
, "listen");
7509 DEFSYM (Qlocal
, "local");
7510 DEFSYM (Qipv4
, "ipv4");
7512 DEFSYM (Qipv6
, "ipv6");
7514 DEFSYM (Qdatagram
, "datagram");
7515 DEFSYM (Qseqpacket
, "seqpacket");
7517 DEFSYM (QCport
, ":port");
7518 DEFSYM (QCspeed
, ":speed");
7519 DEFSYM (QCprocess
, ":process");
7521 DEFSYM (QCbytesize
, ":bytesize");
7522 DEFSYM (QCstopbits
, ":stopbits");
7523 DEFSYM (QCparity
, ":parity");
7524 DEFSYM (Qodd
, "odd");
7525 DEFSYM (Qeven
, "even");
7526 DEFSYM (QCflowcontrol
, ":flowcontrol");
7529 DEFSYM (QCsummary
, ":summary");
7531 DEFSYM (Qreal
, "real");
7532 DEFSYM (Qnetwork
, "network");
7533 DEFSYM (Qserial
, "serial");
7534 DEFSYM (QCbuffer
, ":buffer");
7535 DEFSYM (QChost
, ":host");
7536 DEFSYM (QCservice
, ":service");
7537 DEFSYM (QClocal
, ":local");
7538 DEFSYM (QCremote
, ":remote");
7539 DEFSYM (QCcoding
, ":coding");
7540 DEFSYM (QCserver
, ":server");
7541 DEFSYM (QCnowait
, ":nowait");
7542 DEFSYM (QCsentinel
, ":sentinel");
7543 DEFSYM (QClog
, ":log");
7544 DEFSYM (QCnoquery
, ":noquery");
7545 DEFSYM (QCstop
, ":stop");
7546 DEFSYM (QCoptions
, ":options");
7547 DEFSYM (QCplist
, ":plist");
7549 DEFSYM (Qlast_nonmenu_event
, "last-nonmenu-event");
7551 staticpro (&Vprocess_alist
);
7553 staticpro (&deleted_pid_list
);
7556 #endif /* subprocesses */
7558 DEFSYM (QCname
, ":name");
7559 DEFSYM (QCtype
, ":type");
7561 DEFSYM (Qeuid
, "euid");
7562 DEFSYM (Qegid
, "egid");
7563 DEFSYM (Quser
, "user");
7564 DEFSYM (Qgroup
, "group");
7565 DEFSYM (Qcomm
, "comm");
7566 DEFSYM (Qstate
, "state");
7567 DEFSYM (Qppid
, "ppid");
7568 DEFSYM (Qpgrp
, "pgrp");
7569 DEFSYM (Qsess
, "sess");
7570 DEFSYM (Qttname
, "ttname");
7571 DEFSYM (Qtpgid
, "tpgid");
7572 DEFSYM (Qminflt
, "minflt");
7573 DEFSYM (Qmajflt
, "majflt");
7574 DEFSYM (Qcminflt
, "cminflt");
7575 DEFSYM (Qcmajflt
, "cmajflt");
7576 DEFSYM (Qutime
, "utime");
7577 DEFSYM (Qstime
, "stime");
7578 DEFSYM (Qtime
, "time");
7579 DEFSYM (Qcutime
, "cutime");
7580 DEFSYM (Qcstime
, "cstime");
7581 DEFSYM (Qctime
, "ctime");
7582 DEFSYM (Qpri
, "pri");
7583 DEFSYM (Qnice
, "nice");
7584 DEFSYM (Qthcount
, "thcount");
7585 DEFSYM (Qstart
, "start");
7586 DEFSYM (Qvsize
, "vsize");
7587 DEFSYM (Qrss
, "rss");
7588 DEFSYM (Qetime
, "etime");
7589 DEFSYM (Qpcpu
, "pcpu");
7590 DEFSYM (Qpmem
, "pmem");
7591 DEFSYM (Qargs
, "args");
7593 DEFVAR_BOOL ("delete-exited-processes", delete_exited_processes
,
7594 doc
: /* Non-nil means delete processes immediately when they exit.
7595 A value of nil means don't delete them until `list-processes' is run. */);
7597 delete_exited_processes
= 1;
7600 DEFVAR_LISP ("process-connection-type", Vprocess_connection_type
,
7601 doc
: /* Control type of device used to communicate with subprocesses.
7602 Values are nil to use a pipe, or t or `pty' to use a pty.
7603 The value has no effect if the system has no ptys or if all ptys are busy:
7604 then a pipe is used in any case.
7605 The value takes effect when `start-process' is called. */);
7606 Vprocess_connection_type
= Qt
;
7608 #ifdef ADAPTIVE_READ_BUFFERING
7609 DEFVAR_LISP ("process-adaptive-read-buffering", Vprocess_adaptive_read_buffering
,
7610 doc
: /* If non-nil, improve receive buffering by delaying after short reads.
7611 On some systems, when Emacs reads the output from a subprocess, the output data
7612 is read in very small blocks, potentially resulting in very poor performance.
7613 This behavior can be remedied to some extent by setting this variable to a
7614 non-nil value, as it will automatically delay reading from such processes, to
7615 allow them to produce more output before Emacs tries to read it.
7616 If the value is t, the delay is reset after each write to the process; any other
7617 non-nil value means that the delay is not reset on write.
7618 The variable takes effect when `start-process' is called. */);
7619 Vprocess_adaptive_read_buffering
= Qt
;
7622 defsubr (&Sprocessp
);
7623 defsubr (&Sget_process
);
7624 defsubr (&Sdelete_process
);
7625 defsubr (&Sprocess_status
);
7626 defsubr (&Sprocess_exit_status
);
7627 defsubr (&Sprocess_id
);
7628 defsubr (&Sprocess_name
);
7629 defsubr (&Sprocess_tty_name
);
7630 defsubr (&Sprocess_command
);
7631 defsubr (&Sset_process_buffer
);
7632 defsubr (&Sprocess_buffer
);
7633 defsubr (&Sprocess_mark
);
7634 defsubr (&Sset_process_filter
);
7635 defsubr (&Sprocess_filter
);
7636 defsubr (&Sset_process_sentinel
);
7637 defsubr (&Sprocess_sentinel
);
7638 defsubr (&Sset_process_window_size
);
7639 defsubr (&Sset_process_inherit_coding_system_flag
);
7640 defsubr (&Sset_process_query_on_exit_flag
);
7641 defsubr (&Sprocess_query_on_exit_flag
);
7642 defsubr (&Sprocess_contact
);
7643 defsubr (&Sprocess_plist
);
7644 defsubr (&Sset_process_plist
);
7645 defsubr (&Sprocess_list
);
7646 defsubr (&Sstart_process
);
7647 defsubr (&Sserial_process_configure
);
7648 defsubr (&Smake_serial_process
);
7649 defsubr (&Sset_network_process_option
);
7650 defsubr (&Smake_network_process
);
7651 defsubr (&Sformat_network_address
);
7652 #if defined (HAVE_NET_IF_H)
7654 defsubr (&Snetwork_interface_list
);
7656 #if defined (SIOCGIFADDR) || defined (SIOCGIFHWADDR) || defined (SIOCGIFFLAGS)
7657 defsubr (&Snetwork_interface_info
);
7659 #endif /* defined (HAVE_NET_IF_H) */
7660 #ifdef DATAGRAM_SOCKETS
7661 defsubr (&Sprocess_datagram_address
);
7662 defsubr (&Sset_process_datagram_address
);
7664 defsubr (&Saccept_process_output
);
7665 defsubr (&Sprocess_send_region
);
7666 defsubr (&Sprocess_send_string
);
7667 defsubr (&Sinterrupt_process
);
7668 defsubr (&Skill_process
);
7669 defsubr (&Squit_process
);
7670 defsubr (&Sstop_process
);
7671 defsubr (&Scontinue_process
);
7672 defsubr (&Sprocess_running_child_p
);
7673 defsubr (&Sprocess_send_eof
);
7674 defsubr (&Ssignal_process
);
7675 defsubr (&Swaiting_for_user_input_p
);
7676 defsubr (&Sprocess_type
);
7677 defsubr (&Sset_process_coding_system
);
7678 defsubr (&Sprocess_coding_system
);
7679 defsubr (&Sset_process_filter_multibyte
);
7680 defsubr (&Sprocess_filter_multibyte_p
);
7682 #endif /* subprocesses */
7684 defsubr (&Sget_buffer_process
);
7685 defsubr (&Sprocess_inherit_coding_system_flag
);
7686 defsubr (&Slist_system_processes
);
7687 defsubr (&Sprocess_attributes
);