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
30 #include <sys/types.h> /* Some typedefs are used in sys/file.h. */
40 /* Only MS-DOS does not define `subprocesses'. */
43 #include <sys/socket.h>
45 #include <netinet/in.h>
46 #include <arpa/inet.h>
48 /* Are local (unix) sockets supported? */
49 #if defined (HAVE_SYS_UN_H)
50 #if !defined (AF_LOCAL) && defined (AF_UNIX)
51 #define AF_LOCAL AF_UNIX
54 #define HAVE_LOCAL_SOCKETS
59 #include <sys/ioctl.h>
60 #if defined (HAVE_NET_IF_H)
62 #endif /* HAVE_NET_IF_H */
64 #if defined (HAVE_IFADDRS_H)
65 /* Must be after net/if.h */
68 /* We only use structs from this header when we use getifaddrs. */
69 #if defined (HAVE_NET_IF_DL_H)
70 #include <net/if_dl.h>
80 #include <netinet/in.h>
81 #include <arpa/nameser.h>
93 #endif /* subprocesses */
99 #include "character.h"
104 #include "termhooks.h"
105 #include "termopts.h"
106 #include "commands.h"
107 #include "keyboard.h"
108 #include "blockinput.h"
109 #include "dispextern.h"
110 #include "composite.h"
112 #include "sysselect.h"
113 #include "syssignal.h"
119 #ifdef HAVE_WINDOW_SYSTEM
121 #endif /* HAVE_WINDOW_SYSTEM */
123 #if defined (USE_GTK) || defined (HAVE_GCONF) || defined (HAVE_GSETTINGS)
124 #include "xgselect.h"
129 # define waitpid(pid, status, options) wait (status)
135 /* Work around GCC 4.7.0 bug with strict overflow checking; see
136 <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=52904>.
137 These lines can be removed once the GCC bug is fixed. */
138 #if (__GNUC__ == 4 && 3 <= __GNUC_MINOR__) || 4 < __GNUC__
139 # pragma GCC diagnostic ignored "-Wstrict-overflow"
142 Lisp_Object Qeuid
, Qegid
, Qcomm
, Qstate
, Qppid
, Qpgrp
, Qsess
, Qttname
, Qtpgid
;
143 Lisp_Object Qminflt
, Qmajflt
, Qcminflt
, Qcmajflt
, Qutime
, Qstime
, Qcstime
;
144 Lisp_Object Qcutime
, Qpri
, Qnice
, Qthcount
, Qstart
, Qvsize
, Qrss
, Qargs
;
145 Lisp_Object Quser
, Qgroup
, Qetime
, Qpcpu
, Qpmem
, Qtime
, Qctime
;
146 Lisp_Object QCname
, QCtype
;
148 /* Non-zero if keyboard input is on hold, zero otherwise. */
150 static int kbd_is_on_hold
;
152 /* Nonzero means don't run process sentinels. This is used
154 int inhibit_sentinels
;
158 Lisp_Object Qprocessp
;
159 static Lisp_Object Qrun
, Qstop
, Qsignal
;
160 static Lisp_Object Qopen
, Qclosed
, Qconnect
, Qfailed
, Qlisten
;
162 static Lisp_Object Qipv4
, Qdatagram
, Qseqpacket
;
163 static Lisp_Object Qreal
, Qnetwork
, Qserial
;
165 static Lisp_Object Qipv6
;
167 static Lisp_Object QCport
, QCprocess
;
169 Lisp_Object QCbytesize
, QCstopbits
, QCparity
, Qodd
, Qeven
;
170 Lisp_Object QCflowcontrol
, Qhw
, Qsw
, QCsummary
;
171 static Lisp_Object QCbuffer
, QChost
, QCservice
;
172 static Lisp_Object QClocal
, QCremote
, QCcoding
;
173 static Lisp_Object QCserver
, QCnowait
, QCnoquery
, QCstop
;
174 static Lisp_Object QCsentinel
, QClog
, QCoptions
, QCplist
;
175 static Lisp_Object Qlast_nonmenu_event
;
177 #define NETCONN_P(p) (EQ (XPROCESS (p)->type, Qnetwork))
178 #define NETCONN1_P(p) (EQ (p->type, Qnetwork))
179 #define SERIALCONN_P(p) (EQ (XPROCESS (p)->type, Qserial))
180 #define SERIALCONN1_P(p) (EQ (p->type, Qserial))
186 /* Number of events of change of status of a process. */
187 static EMACS_INT process_tick
;
188 /* Number of events for which the user or sentinel has been notified. */
189 static EMACS_INT update_tick
;
191 /* Define NON_BLOCKING_CONNECT if we can support non-blocking connects. */
193 /* Only W32 has this, it really means that select can't take write mask. */
194 #ifdef BROKEN_NON_BLOCKING_CONNECT
195 #undef NON_BLOCKING_CONNECT
196 #define SELECT_CANT_DO_WRITE_MASK
198 #ifndef NON_BLOCKING_CONNECT
200 #if defined (HAVE_GETPEERNAME) || defined (GNU_LINUX)
201 #if defined (O_NONBLOCK) || defined (O_NDELAY)
202 #if defined (EWOULDBLOCK) || defined (EINPROGRESS)
203 #define NON_BLOCKING_CONNECT
204 #endif /* EWOULDBLOCK || EINPROGRESS */
205 #endif /* O_NONBLOCK || O_NDELAY */
206 #endif /* HAVE_GETPEERNAME || GNU_LINUX */
207 #endif /* HAVE_SELECT */
208 #endif /* NON_BLOCKING_CONNECT */
209 #endif /* BROKEN_NON_BLOCKING_CONNECT */
211 /* Define DATAGRAM_SOCKETS if datagrams can be used safely on
212 this system. We need to read full packets, so we need a
213 "non-destructive" select. So we require either native select,
214 or emulation of select using FIONREAD. */
216 #ifdef BROKEN_DATAGRAM_SOCKETS
217 #undef DATAGRAM_SOCKETS
219 #ifndef DATAGRAM_SOCKETS
220 #if defined (HAVE_SELECT) || defined (FIONREAD)
221 #if defined (HAVE_SENDTO) && defined (HAVE_RECVFROM) && defined (EMSGSIZE)
222 #define DATAGRAM_SOCKETS
223 #endif /* HAVE_SENDTO && HAVE_RECVFROM && EMSGSIZE */
224 #endif /* HAVE_SELECT || FIONREAD */
225 #endif /* DATAGRAM_SOCKETS */
226 #endif /* BROKEN_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];
1617 struct sigaction sigint_action
;
1618 struct sigaction sigquit_action
;
1619 struct sigaction sigpipe_action
;
1621 struct sigaction sighup_action
;
1623 /* Use volatile to protect variables from being clobbered by longjmp. */
1624 volatile int forkin
, forkout
;
1625 volatile int pty_flag
= 0;
1627 inchannel
= outchannel
= -1;
1630 if (!NILP (Vprocess_connection_type
))
1631 outchannel
= inchannel
= allocate_pty ();
1635 #if ! defined (USG) || defined (USG_SUBTTY_WORKS)
1636 /* On most USG systems it does not work to open the pty's tty here,
1637 then close it and reopen it in the child. */
1639 /* Don't let this terminal become our controlling terminal
1640 (in case we don't have one). */
1641 forkout
= forkin
= emacs_open (pty_name
, O_RDWR
| O_NOCTTY
, 0);
1643 forkout
= forkin
= emacs_open (pty_name
, O_RDWR
, 0);
1646 report_file_error ("Opening pty", Qnil
);
1648 forkin
= forkout
= -1;
1649 #endif /* not USG, or USG_SUBTTY_WORKS */
1653 #endif /* HAVE_PTYS */
1658 report_file_error ("Creating pipe", Qnil
);
1664 emacs_close (inchannel
);
1665 emacs_close (forkout
);
1666 report_file_error ("Creating pipe", Qnil
);
1672 #if !defined (WINDOWSNT) && defined (FD_CLOEXEC)
1676 tem
= pipe (wait_child_setup
);
1678 report_file_error ("Creating pipe", Qnil
);
1679 tem
= fcntl (wait_child_setup
[1], F_GETFD
, 0);
1681 tem
= fcntl (wait_child_setup
[1], F_SETFD
, tem
| FD_CLOEXEC
);
1684 emacs_close (wait_child_setup
[0]);
1685 emacs_close (wait_child_setup
[1]);
1686 report_file_error ("Setting file descriptor flags", Qnil
);
1692 fcntl (inchannel
, F_SETFL
, O_NONBLOCK
);
1693 fcntl (outchannel
, F_SETFL
, O_NONBLOCK
);
1696 fcntl (inchannel
, F_SETFL
, O_NDELAY
);
1697 fcntl (outchannel
, F_SETFL
, O_NDELAY
);
1701 /* Record this as an active process, with its channels.
1702 As a result, child_setup will close Emacs's side of the pipes. */
1703 chan_process
[inchannel
] = process
;
1704 XPROCESS (process
)->infd
= inchannel
;
1705 XPROCESS (process
)->outfd
= outchannel
;
1707 /* Previously we recorded the tty descriptor used in the subprocess.
1708 It was only used for getting the foreground tty process, so now
1709 we just reopen the device (see emacs_get_tty_pgrp) as this is
1710 more portable (see USG_SUBTTY_WORKS above). */
1712 XPROCESS (process
)->pty_flag
= pty_flag
;
1713 pset_status (XPROCESS (process
), Qrun
);
1715 /* Delay interrupts until we have a chance to store
1716 the new fork's pid in its process structure */
1717 sigemptyset (&blocked
);
1719 sigaddset (&blocked
, SIGCHLD
);
1721 #ifdef HAVE_WORKING_VFORK
1722 /* On many hosts (e.g. Solaris 2.4), if a vforked child calls `signal',
1723 this sets the parent's signal handlers as well as the child's.
1724 So delay all interrupts whose handlers the child might munge,
1725 and record the current handlers so they can be restored later. */
1726 sigaddset (&blocked
, SIGINT
); sigaction (SIGINT
, 0, &sigint_action
);
1727 sigaddset (&blocked
, SIGQUIT
); sigaction (SIGQUIT
, 0, &sigquit_action
);
1728 sigaddset (&blocked
, SIGPIPE
); sigaction (SIGPIPE
, 0, &sigpipe_action
);
1730 sigaddset (&blocked
, SIGHUP
); sigaction (SIGHUP
, 0, &sighup_action
);
1732 #endif /* HAVE_WORKING_VFORK */
1733 pthread_sigmask (SIG_BLOCK
, &blocked
, &procmask
);
1735 FD_SET (inchannel
, &input_wait_mask
);
1736 FD_SET (inchannel
, &non_keyboard_wait_mask
);
1737 if (inchannel
> max_process_desc
)
1738 max_process_desc
= inchannel
;
1740 /* Until we store the proper pid, enable the SIGCHLD handler
1741 to recognize an unknown pid as standing for this process.
1742 It is very important not to let this `marker' value stay
1743 in the table after this function has returned; if it does
1744 it might cause call-process to hang and subsequent asynchronous
1745 processes to get their return values scrambled. */
1746 XPROCESS (process
)->pid
= -1;
1748 /* This must be called after the above line because it may signal an
1750 setup_process_coding_systems (process
);
1755 /* child_setup must clobber environ on systems with true vfork.
1756 Protect it from permanent change. */
1757 char **save_environ
= environ
;
1758 volatile Lisp_Object encoded_current_dir
= ENCODE_FILE (current_dir
);
1763 #endif /* not WINDOWSNT */
1765 int xforkin
= forkin
;
1766 int xforkout
= forkout
;
1768 #if 0 /* This was probably a mistake--it duplicates code later on,
1769 but fails to handle all the cases. */
1770 /* Make sure SIGCHLD is not blocked in the child. */
1771 sigsetmask (SIGEMPTYMASK
);
1774 /* Make the pty be the controlling terminal of the process. */
1776 /* First, disconnect its current controlling terminal. */
1778 /* We tried doing setsid only if pty_flag, but it caused
1779 process_set_signal to fail on SGI when using a pipe. */
1781 /* Make the pty's terminal the controlling terminal. */
1782 if (pty_flag
&& xforkin
>= 0)
1785 /* We ignore the return value
1786 because faith@cs.unc.edu says that is necessary on Linux. */
1787 ioctl (xforkin
, TIOCSCTTY
, 0);
1790 #else /* not HAVE_SETSID */
1792 /* It's very important to call setpgrp here and no time
1793 afterwards. Otherwise, we lose our controlling tty which
1794 is set when we open the pty. */
1797 #endif /* not HAVE_SETSID */
1798 #if defined (LDISC1)
1799 if (pty_flag
&& xforkin
>= 0)
1802 tcgetattr (xforkin
, &t
);
1804 if (tcsetattr (xforkin
, TCSANOW
, &t
) < 0)
1805 emacs_write (1, "create_process/tcsetattr LDISC1 failed\n", 39);
1808 #if defined (NTTYDISC) && defined (TIOCSETD)
1809 if (pty_flag
&& xforkin
>= 0)
1811 /* Use new line discipline. */
1812 int ldisc
= NTTYDISC
;
1813 ioctl (xforkin
, TIOCSETD
, &ldisc
);
1818 /* In 4.3BSD, the TIOCSPGRP bug has been fixed, and now you
1819 can do TIOCSPGRP only to the process's controlling tty. */
1822 /* I wonder: would just ioctl (0, TIOCNOTTY, 0) work here?
1823 I can't test it since I don't have 4.3. */
1824 int j
= emacs_open ("/dev/tty", O_RDWR
, 0);
1827 ioctl (j
, TIOCNOTTY
, 0);
1831 /* In order to get a controlling terminal on some versions
1832 of BSD, it is necessary to put the process in pgrp 0
1833 before it opens the terminal. */
1841 #endif /* TIOCNOTTY */
1843 #if !defined (DONT_REOPEN_PTY)
1844 /*** There is a suggestion that this ought to be a
1845 conditional on TIOCSPGRP,
1846 or !(defined (HAVE_SETSID) && defined (TIOCSCTTY)).
1847 Trying the latter gave the wrong results on Debian GNU/Linux 1.1;
1848 that system does seem to need this code, even though
1849 both HAVE_SETSID and TIOCSCTTY are defined. */
1850 /* Now close the pty (if we had it open) and reopen it.
1851 This makes the pty the controlling terminal of the subprocess. */
1855 /* I wonder if emacs_close (emacs_open (pty_name, ...))
1858 emacs_close (xforkin
);
1859 xforkout
= xforkin
= emacs_open (pty_name
, O_RDWR
, 0);
1863 emacs_write (1, "Couldn't open the pty terminal ", 31);
1864 emacs_write (1, pty_name
, strlen (pty_name
));
1865 emacs_write (1, "\n", 1);
1870 #endif /* not DONT_REOPEN_PTY */
1872 #ifdef SETUP_SLAVE_PTY
1877 #endif /* SETUP_SLAVE_PTY */
1879 /* On AIX, we've disabled SIGHUP above once we start a child on a pty.
1880 Now reenable it in the child, so it will die when we want it to. */
1882 signal (SIGHUP
, SIG_DFL
);
1884 #endif /* HAVE_PTYS */
1886 signal (SIGINT
, SIG_DFL
);
1887 signal (SIGQUIT
, SIG_DFL
);
1888 /* GConf causes us to ignore SIGPIPE, make sure it is restored
1890 signal (SIGPIPE
, SIG_DFL
);
1892 /* Stop blocking signals in the child. */
1893 pthread_sigmask (SIG_SETMASK
, &procmask
, 0);
1896 child_setup_tty (xforkout
);
1898 pid
= child_setup (xforkin
, xforkout
, xforkout
,
1899 new_argv
, 1, encoded_current_dir
);
1900 #else /* not WINDOWSNT */
1902 emacs_close (wait_child_setup
[0]);
1904 child_setup (xforkin
, xforkout
, xforkout
,
1905 new_argv
, 1, encoded_current_dir
);
1906 #endif /* not WINDOWSNT */
1908 environ
= save_environ
;
1913 /* This runs in the Emacs process. */
1917 emacs_close (forkin
);
1918 if (forkin
!= forkout
&& forkout
>= 0)
1919 emacs_close (forkout
);
1923 /* vfork succeeded. */
1924 XPROCESS (process
)->pid
= pid
;
1927 register_child (pid
, inchannel
);
1928 #endif /* WINDOWSNT */
1930 /* If the subfork execv fails, and it exits,
1931 this close hangs. I don't know why.
1932 So have an interrupt jar it loose. */
1934 struct atimer
*timer
;
1935 EMACS_TIME offset
= make_emacs_time (1, 0);
1938 timer
= start_atimer (ATIMER_RELATIVE
, offset
, create_process_1
, 0);
1941 emacs_close (forkin
);
1943 cancel_atimer (timer
);
1947 if (forkin
!= forkout
&& forkout
>= 0)
1948 emacs_close (forkout
);
1952 pset_tty_name (XPROCESS (process
), build_string (pty_name
));
1955 pset_tty_name (XPROCESS (process
), Qnil
);
1957 #if !defined (WINDOWSNT) && defined (FD_CLOEXEC)
1958 /* Wait for child_setup to complete in case that vfork is
1959 actually defined as fork. The descriptor wait_child_setup[1]
1960 of a pipe is closed at the child side either by close-on-exec
1961 on successful execvp or the _exit call in child_setup. */
1965 emacs_close (wait_child_setup
[1]);
1966 emacs_read (wait_child_setup
[0], &dummy
, 1);
1967 emacs_close (wait_child_setup
[0]);
1972 /* Restore the signal state whether vfork succeeded or not.
1973 (We will signal an error, below, if it failed.) */
1974 #ifdef HAVE_WORKING_VFORK
1975 /* Restore the parent's signal handlers. */
1976 sigaction (SIGINT
, &sigint_action
, 0);
1977 sigaction (SIGQUIT
, &sigquit_action
, 0);
1978 sigaction (SIGPIPE
, &sigpipe_action
, 0);
1980 sigaction (SIGHUP
, &sighup_action
, 0);
1982 #endif /* HAVE_WORKING_VFORK */
1983 /* Stop blocking signals in the parent. */
1984 pthread_sigmask (SIG_SETMASK
, &procmask
, 0);
1986 /* Now generate the error if vfork failed. */
1988 report_file_error ("Doing vfork", Qnil
);
1992 create_pty (Lisp_Object process
)
1994 int inchannel
, outchannel
;
1997 inchannel
= outchannel
= -1;
2000 if (!NILP (Vprocess_connection_type
))
2001 outchannel
= inchannel
= allocate_pty ();
2005 #if ! defined (USG) || defined (USG_SUBTTY_WORKS)
2006 /* On most USG systems it does not work to open the pty's tty here,
2007 then close it and reopen it in the child. */
2009 /* Don't let this terminal become our controlling terminal
2010 (in case we don't have one). */
2011 int forkout
= emacs_open (pty_name
, O_RDWR
| O_NOCTTY
, 0);
2013 int forkout
= emacs_open (pty_name
, O_RDWR
, 0);
2016 report_file_error ("Opening pty", Qnil
);
2017 #if defined (DONT_REOPEN_PTY)
2018 /* In the case that vfork is defined as fork, the parent process
2019 (Emacs) may send some data before the child process completes
2020 tty options setup. So we setup tty before forking. */
2021 child_setup_tty (forkout
);
2022 #endif /* DONT_REOPEN_PTY */
2023 #endif /* not USG, or USG_SUBTTY_WORKS */
2026 #endif /* HAVE_PTYS */
2029 fcntl (inchannel
, F_SETFL
, O_NONBLOCK
);
2030 fcntl (outchannel
, F_SETFL
, O_NONBLOCK
);
2033 fcntl (inchannel
, F_SETFL
, O_NDELAY
);
2034 fcntl (outchannel
, F_SETFL
, O_NDELAY
);
2038 /* Record this as an active process, with its channels.
2039 As a result, child_setup will close Emacs's side of the pipes. */
2040 chan_process
[inchannel
] = process
;
2041 XPROCESS (process
)->infd
= inchannel
;
2042 XPROCESS (process
)->outfd
= outchannel
;
2044 /* Previously we recorded the tty descriptor used in the subprocess.
2045 It was only used for getting the foreground tty process, so now
2046 we just reopen the device (see emacs_get_tty_pgrp) as this is
2047 more portable (see USG_SUBTTY_WORKS above). */
2049 XPROCESS (process
)->pty_flag
= pty_flag
;
2050 pset_status (XPROCESS (process
), Qrun
);
2051 setup_process_coding_systems (process
);
2053 FD_SET (inchannel
, &input_wait_mask
);
2054 FD_SET (inchannel
, &non_keyboard_wait_mask
);
2055 if (inchannel
> max_process_desc
)
2056 max_process_desc
= inchannel
;
2058 XPROCESS (process
)->pid
= -2;
2061 pset_tty_name (XPROCESS (process
), build_string (pty_name
));
2064 pset_tty_name (XPROCESS (process
), Qnil
);
2068 /* Convert an internal struct sockaddr to a lisp object (vector or string).
2069 The address family of sa is not included in the result. */
2072 conv_sockaddr_to_lisp (struct sockaddr
*sa
, int len
)
2074 Lisp_Object address
;
2077 register struct Lisp_Vector
*p
;
2079 /* Workaround for a bug in getsockname on BSD: Names bound to
2080 sockets in the UNIX domain are inaccessible; getsockname returns
2081 a zero length name. */
2082 if (len
< offsetof (struct sockaddr
, sa_family
) + sizeof (sa
->sa_family
))
2083 return empty_unibyte_string
;
2085 switch (sa
->sa_family
)
2089 struct sockaddr_in
*sin
= (struct sockaddr_in
*) sa
;
2090 len
= sizeof (sin
->sin_addr
) + 1;
2091 address
= Fmake_vector (make_number (len
), Qnil
);
2092 p
= XVECTOR (address
);
2093 p
->contents
[--len
] = make_number (ntohs (sin
->sin_port
));
2094 cp
= (unsigned char *) &sin
->sin_addr
;
2100 struct sockaddr_in6
*sin6
= (struct sockaddr_in6
*) sa
;
2101 uint16_t *ip6
= (uint16_t *) &sin6
->sin6_addr
;
2102 len
= sizeof (sin6
->sin6_addr
)/2 + 1;
2103 address
= Fmake_vector (make_number (len
), Qnil
);
2104 p
= XVECTOR (address
);
2105 p
->contents
[--len
] = make_number (ntohs (sin6
->sin6_port
));
2106 for (i
= 0; i
< len
; i
++)
2107 p
->contents
[i
] = make_number (ntohs (ip6
[i
]));
2111 #ifdef HAVE_LOCAL_SOCKETS
2114 struct sockaddr_un
*sockun
= (struct sockaddr_un
*) sa
;
2115 for (i
= 0; i
< sizeof (sockun
->sun_path
); i
++)
2116 if (sockun
->sun_path
[i
] == 0)
2118 return make_unibyte_string (sockun
->sun_path
, i
);
2122 len
-= offsetof (struct sockaddr
, sa_family
) + sizeof (sa
->sa_family
);
2123 address
= Fcons (make_number (sa
->sa_family
),
2124 Fmake_vector (make_number (len
), Qnil
));
2125 p
= XVECTOR (XCDR (address
));
2126 cp
= (unsigned char *) &sa
->sa_family
+ sizeof (sa
->sa_family
);
2132 p
->contents
[i
++] = make_number (*cp
++);
2138 /* Get family and required size for sockaddr structure to hold ADDRESS. */
2141 get_lisp_to_sockaddr_size (Lisp_Object address
, int *familyp
)
2143 register struct Lisp_Vector
*p
;
2145 if (VECTORP (address
))
2147 p
= XVECTOR (address
);
2148 if (p
->header
.size
== 5)
2151 return sizeof (struct sockaddr_in
);
2154 else if (p
->header
.size
== 9)
2156 *familyp
= AF_INET6
;
2157 return sizeof (struct sockaddr_in6
);
2161 #ifdef HAVE_LOCAL_SOCKETS
2162 else if (STRINGP (address
))
2164 *familyp
= AF_LOCAL
;
2165 return sizeof (struct sockaddr_un
);
2168 else if (CONSP (address
) && TYPE_RANGED_INTEGERP (int, XCAR (address
))
2169 && VECTORP (XCDR (address
)))
2171 struct sockaddr
*sa
;
2172 *familyp
= XINT (XCAR (address
));
2173 p
= XVECTOR (XCDR (address
));
2174 return p
->header
.size
+ sizeof (sa
->sa_family
);
2179 /* Convert an address object (vector or string) to an internal sockaddr.
2181 The address format has been basically validated by
2182 get_lisp_to_sockaddr_size, but this does not mean FAMILY is valid;
2183 it could have come from user data. So if FAMILY is not valid,
2184 we return after zeroing *SA. */
2187 conv_lisp_to_sockaddr (int family
, Lisp_Object address
, struct sockaddr
*sa
, int len
)
2189 register struct Lisp_Vector
*p
;
2190 register unsigned char *cp
= NULL
;
2194 memset (sa
, 0, len
);
2196 if (VECTORP (address
))
2198 p
= XVECTOR (address
);
2199 if (family
== AF_INET
)
2201 struct sockaddr_in
*sin
= (struct sockaddr_in
*) sa
;
2202 len
= sizeof (sin
->sin_addr
) + 1;
2203 hostport
= XINT (p
->contents
[--len
]);
2204 sin
->sin_port
= htons (hostport
);
2205 cp
= (unsigned char *)&sin
->sin_addr
;
2206 sa
->sa_family
= family
;
2209 else if (family
== AF_INET6
)
2211 struct sockaddr_in6
*sin6
= (struct sockaddr_in6
*) sa
;
2212 uint16_t *ip6
= (uint16_t *)&sin6
->sin6_addr
;
2213 len
= sizeof (sin6
->sin6_addr
) + 1;
2214 hostport
= XINT (p
->contents
[--len
]);
2215 sin6
->sin6_port
= htons (hostport
);
2216 for (i
= 0; i
< len
; i
++)
2217 if (INTEGERP (p
->contents
[i
]))
2219 int j
= XFASTINT (p
->contents
[i
]) & 0xffff;
2222 sa
->sa_family
= family
;
2229 else if (STRINGP (address
))
2231 #ifdef HAVE_LOCAL_SOCKETS
2232 if (family
== AF_LOCAL
)
2234 struct sockaddr_un
*sockun
= (struct sockaddr_un
*) sa
;
2235 cp
= SDATA (address
);
2236 for (i
= 0; i
< sizeof (sockun
->sun_path
) && *cp
; i
++)
2237 sockun
->sun_path
[i
] = *cp
++;
2238 sa
->sa_family
= family
;
2245 p
= XVECTOR (XCDR (address
));
2246 cp
= (unsigned char *)sa
+ sizeof (sa
->sa_family
);
2249 for (i
= 0; i
< len
; i
++)
2250 if (INTEGERP (p
->contents
[i
]))
2251 *cp
++ = XFASTINT (p
->contents
[i
]) & 0xff;
2254 #ifdef DATAGRAM_SOCKETS
2255 DEFUN ("process-datagram-address", Fprocess_datagram_address
, Sprocess_datagram_address
,
2257 doc
: /* Get the current datagram address associated with PROCESS. */)
2258 (Lisp_Object process
)
2262 CHECK_PROCESS (process
);
2264 if (!DATAGRAM_CONN_P (process
))
2267 channel
= XPROCESS (process
)->infd
;
2268 return conv_sockaddr_to_lisp (datagram_address
[channel
].sa
,
2269 datagram_address
[channel
].len
);
2272 DEFUN ("set-process-datagram-address", Fset_process_datagram_address
, Sset_process_datagram_address
,
2274 doc
: /* Set the datagram address for PROCESS to ADDRESS.
2275 Returns nil upon error setting address, ADDRESS otherwise. */)
2276 (Lisp_Object process
, Lisp_Object address
)
2281 CHECK_PROCESS (process
);
2283 if (!DATAGRAM_CONN_P (process
))
2286 channel
= XPROCESS (process
)->infd
;
2288 len
= get_lisp_to_sockaddr_size (address
, &family
);
2289 if (datagram_address
[channel
].len
!= len
)
2291 conv_lisp_to_sockaddr (family
, address
, datagram_address
[channel
].sa
, len
);
2297 static const struct socket_options
{
2298 /* The name of this option. Should be lowercase version of option
2299 name without SO_ prefix. */
2301 /* Option level SOL_... */
2303 /* Option number SO_... */
2305 enum { SOPT_UNKNOWN
, SOPT_BOOL
, SOPT_INT
, SOPT_IFNAME
, SOPT_LINGER
} opttype
;
2306 enum { OPIX_NONE
=0, OPIX_MISC
=1, OPIX_REUSEADDR
=2 } optbit
;
2307 } socket_options
[] =
2309 #ifdef SO_BINDTODEVICE
2310 { ":bindtodevice", SOL_SOCKET
, SO_BINDTODEVICE
, SOPT_IFNAME
, OPIX_MISC
},
2313 { ":broadcast", SOL_SOCKET
, SO_BROADCAST
, SOPT_BOOL
, OPIX_MISC
},
2316 { ":dontroute", SOL_SOCKET
, SO_DONTROUTE
, SOPT_BOOL
, OPIX_MISC
},
2319 { ":keepalive", SOL_SOCKET
, SO_KEEPALIVE
, SOPT_BOOL
, OPIX_MISC
},
2322 { ":linger", SOL_SOCKET
, SO_LINGER
, SOPT_LINGER
, OPIX_MISC
},
2325 { ":oobinline", SOL_SOCKET
, SO_OOBINLINE
, SOPT_BOOL
, OPIX_MISC
},
2328 { ":priority", SOL_SOCKET
, SO_PRIORITY
, SOPT_INT
, OPIX_MISC
},
2331 { ":reuseaddr", SOL_SOCKET
, SO_REUSEADDR
, SOPT_BOOL
, OPIX_REUSEADDR
},
2333 { 0, 0, 0, SOPT_UNKNOWN
, OPIX_NONE
}
2336 /* Set option OPT to value VAL on socket S.
2338 Returns (1<<socket_options[OPT].optbit) if option is known, 0 otherwise.
2339 Signals an error if setting a known option fails.
2343 set_socket_option (int s
, Lisp_Object opt
, Lisp_Object val
)
2346 const struct socket_options
*sopt
;
2351 name
= SSDATA (SYMBOL_NAME (opt
));
2352 for (sopt
= socket_options
; sopt
->name
; sopt
++)
2353 if (strcmp (name
, sopt
->name
) == 0)
2356 switch (sopt
->opttype
)
2361 optval
= NILP (val
) ? 0 : 1;
2362 ret
= setsockopt (s
, sopt
->optlevel
, sopt
->optnum
,
2363 &optval
, sizeof (optval
));
2370 if (TYPE_RANGED_INTEGERP (int, val
))
2371 optval
= XINT (val
);
2373 error ("Bad option value for %s", name
);
2374 ret
= setsockopt (s
, sopt
->optlevel
, sopt
->optnum
,
2375 &optval
, sizeof (optval
));
2379 #ifdef SO_BINDTODEVICE
2382 char devname
[IFNAMSIZ
+1];
2384 /* This is broken, at least in the Linux 2.4 kernel.
2385 To unbind, the arg must be a zero integer, not the empty string.
2386 This should work on all systems. KFS. 2003-09-23. */
2387 memset (devname
, 0, sizeof devname
);
2390 char *arg
= SSDATA (val
);
2391 int len
= min (strlen (arg
), IFNAMSIZ
);
2392 memcpy (devname
, arg
, len
);
2394 else if (!NILP (val
))
2395 error ("Bad option value for %s", name
);
2396 ret
= setsockopt (s
, sopt
->optlevel
, sopt
->optnum
,
2405 struct linger linger
;
2408 linger
.l_linger
= 0;
2409 if (TYPE_RANGED_INTEGERP (int, val
))
2410 linger
.l_linger
= XINT (val
);
2412 linger
.l_onoff
= NILP (val
) ? 0 : 1;
2413 ret
= setsockopt (s
, sopt
->optlevel
, sopt
->optnum
,
2414 &linger
, sizeof (linger
));
2424 report_file_error ("Cannot set network option",
2425 Fcons (opt
, Fcons (val
, Qnil
)));
2426 return (1 << sopt
->optbit
);
2430 DEFUN ("set-network-process-option",
2431 Fset_network_process_option
, Sset_network_process_option
,
2433 doc
: /* For network process PROCESS set option OPTION to value VALUE.
2434 See `make-network-process' for a list of options and values.
2435 If optional fourth arg NO-ERROR is non-nil, don't signal an error if
2436 OPTION is not a supported option, return nil instead; otherwise return t. */)
2437 (Lisp_Object process
, Lisp_Object option
, Lisp_Object value
, Lisp_Object no_error
)
2440 struct Lisp_Process
*p
;
2442 CHECK_PROCESS (process
);
2443 p
= XPROCESS (process
);
2444 if (!NETCONN1_P (p
))
2445 error ("Process is not a network process");
2449 error ("Process is not running");
2451 if (set_socket_option (s
, option
, value
))
2453 pset_childp (p
, Fplist_put (p
->childp
, option
, value
));
2457 if (NILP (no_error
))
2458 error ("Unknown or unsupported option");
2464 DEFUN ("serial-process-configure",
2465 Fserial_process_configure
,
2466 Sserial_process_configure
,
2468 doc
: /* Configure speed, bytesize, etc. of a serial process.
2470 Arguments are specified as keyword/argument pairs. Attributes that
2471 are not given are re-initialized from the process's current
2472 configuration (available via the function `process-contact') or set to
2473 reasonable default values. The following arguments are defined:
2479 -- Any of these arguments can be given to identify the process that is
2480 to be configured. If none of these arguments is given, the current
2481 buffer's process is used.
2483 :speed SPEED -- SPEED is the speed of the serial port in bits per
2484 second, also called baud rate. Any value can be given for SPEED, but
2485 most serial ports work only at a few defined values between 1200 and
2486 115200, with 9600 being the most common value. If SPEED is nil, the
2487 serial port is not configured any further, i.e., all other arguments
2488 are ignored. This may be useful for special serial ports such as
2489 Bluetooth-to-serial converters which can only be configured through AT
2490 commands. A value of nil for SPEED can be used only when passed
2491 through `make-serial-process' or `serial-term'.
2493 :bytesize BYTESIZE -- BYTESIZE is the number of bits per byte, which
2494 can be 7 or 8. If BYTESIZE is not given or nil, a value of 8 is used.
2496 :parity PARITY -- PARITY can be nil (don't use parity), the symbol
2497 `odd' (use odd parity), or the symbol `even' (use even parity). If
2498 PARITY is not given, no parity is used.
2500 :stopbits STOPBITS -- STOPBITS is the number of stopbits used to
2501 terminate a byte transmission. STOPBITS can be 1 or 2. If STOPBITS
2502 is not given or nil, 1 stopbit is used.
2504 :flowcontrol FLOWCONTROL -- FLOWCONTROL determines the type of
2505 flowcontrol to be used, which is either nil (don't use flowcontrol),
2506 the symbol `hw' (use RTS/CTS hardware flowcontrol), or the symbol `sw'
2507 \(use XON/XOFF software flowcontrol). If FLOWCONTROL is not given, no
2508 flowcontrol is used.
2510 `serial-process-configure' is called by `make-serial-process' for the
2511 initial configuration of the serial port.
2515 \(serial-process-configure :process "/dev/ttyS0" :speed 1200)
2517 \(serial-process-configure
2518 :buffer "COM1" :stopbits 1 :parity 'odd :flowcontrol 'hw)
2520 \(serial-process-configure :port "\\\\.\\COM13" :bytesize 7)
2522 usage: (serial-process-configure &rest ARGS) */)
2523 (ptrdiff_t nargs
, Lisp_Object
*args
)
2525 struct Lisp_Process
*p
;
2526 Lisp_Object contact
= Qnil
;
2527 Lisp_Object proc
= Qnil
;
2528 struct gcpro gcpro1
;
2530 contact
= Flist (nargs
, args
);
2533 proc
= Fplist_get (contact
, QCprocess
);
2535 proc
= Fplist_get (contact
, QCname
);
2537 proc
= Fplist_get (contact
, QCbuffer
);
2539 proc
= Fplist_get (contact
, QCport
);
2540 proc
= get_process (proc
);
2541 p
= XPROCESS (proc
);
2542 if (!EQ (p
->type
, Qserial
))
2543 error ("Not a serial process");
2545 if (NILP (Fplist_get (p
->childp
, QCspeed
)))
2551 serial_configure (p
, contact
);
2557 /* Used by make-serial-process to recover from errors. */
2559 make_serial_process_unwind (Lisp_Object proc
)
2561 if (!PROCESSP (proc
))
2563 remove_process (proc
);
2567 DEFUN ("make-serial-process", Fmake_serial_process
, Smake_serial_process
,
2569 doc
: /* Create and return a serial port process.
2571 In Emacs, serial port connections are represented by process objects,
2572 so input and output work as for subprocesses, and `delete-process'
2573 closes a serial port connection. However, a serial process has no
2574 process id, it cannot be signaled, and the status codes are different
2575 from normal processes.
2577 `make-serial-process' creates a process and a buffer, on which you
2578 probably want to use `process-send-string'. Try \\[serial-term] for
2579 an interactive terminal. See below for examples.
2581 Arguments are specified as keyword/argument pairs. The following
2582 arguments are defined:
2584 :port PORT -- (mandatory) PORT is the path or name of the serial port.
2585 For example, this could be "/dev/ttyS0" on Unix. On Windows, this
2586 could be "COM1", or "\\\\.\\COM10" for ports higher than COM9 (double
2587 the backslashes in strings).
2589 :speed SPEED -- (mandatory) is handled by `serial-process-configure',
2590 which this function calls.
2592 :name NAME -- NAME is the name of the process. If NAME is not given,
2593 the value of PORT is used.
2595 :buffer BUFFER -- BUFFER is the buffer (or buffer-name) to associate
2596 with the process. Process output goes at the end of that buffer,
2597 unless you specify an output stream or filter function to handle the
2598 output. If BUFFER is not given, the value of NAME is used.
2600 :coding CODING -- If CODING is a symbol, it specifies the coding
2601 system used for both reading and writing for this process. If CODING
2602 is a cons (DECODING . ENCODING), DECODING is used for reading, and
2603 ENCODING is used for writing.
2605 :noquery BOOL -- When exiting Emacs, query the user if BOOL is nil and
2606 the process is running. If BOOL is not given, query before exiting.
2608 :stop BOOL -- Start process in the `stopped' state if BOOL is non-nil.
2609 In the stopped state, a serial process does not accept incoming data,
2610 but you can send outgoing data. The stopped state is cleared by
2611 `continue-process' and set by `stop-process'.
2613 :filter FILTER -- Install FILTER as the process filter.
2615 :sentinel SENTINEL -- Install SENTINEL as the process sentinel.
2617 :plist PLIST -- Install PLIST as the initial plist of the process.
2623 -- This function calls `serial-process-configure' to handle these
2626 The original argument list, possibly modified by later configuration,
2627 is available via the function `process-contact'.
2631 \(make-serial-process :port "/dev/ttyS0" :speed 9600)
2633 \(make-serial-process :port "COM1" :speed 115200 :stopbits 2)
2635 \(make-serial-process :port "\\\\.\\COM13" :speed 1200 :bytesize 7 :parity 'odd)
2637 \(make-serial-process :port "/dev/tty.BlueConsole-SPP-1" :speed nil)
2639 usage: (make-serial-process &rest ARGS) */)
2640 (ptrdiff_t nargs
, Lisp_Object
*args
)
2643 Lisp_Object proc
, contact
, port
;
2644 struct Lisp_Process
*p
;
2645 struct gcpro gcpro1
;
2646 Lisp_Object name
, buffer
;
2647 Lisp_Object tem
, val
;
2648 ptrdiff_t specpdl_count
= -1;
2653 contact
= Flist (nargs
, args
);
2656 port
= Fplist_get (contact
, QCport
);
2658 error ("No port specified");
2659 CHECK_STRING (port
);
2661 if (NILP (Fplist_member (contact
, QCspeed
)))
2662 error (":speed not specified");
2663 if (!NILP (Fplist_get (contact
, QCspeed
)))
2664 CHECK_NUMBER (Fplist_get (contact
, QCspeed
));
2666 name
= Fplist_get (contact
, QCname
);
2669 CHECK_STRING (name
);
2670 proc
= make_process (name
);
2671 specpdl_count
= SPECPDL_INDEX ();
2672 record_unwind_protect (make_serial_process_unwind
, proc
);
2673 p
= XPROCESS (proc
);
2675 fd
= serial_open (SSDATA (port
));
2678 if (fd
> max_process_desc
)
2679 max_process_desc
= fd
;
2680 chan_process
[fd
] = proc
;
2682 buffer
= Fplist_get (contact
, QCbuffer
);
2685 buffer
= Fget_buffer_create (buffer
);
2686 pset_buffer (p
, buffer
);
2688 pset_childp (p
, contact
);
2689 pset_plist (p
, Fcopy_sequence (Fplist_get (contact
, QCplist
)));
2690 pset_type (p
, Qserial
);
2691 pset_sentinel (p
, Fplist_get (contact
, QCsentinel
));
2692 pset_filter (p
, Fplist_get (contact
, QCfilter
));
2694 if (tem
= Fplist_get (contact
, QCnoquery
), !NILP (tem
))
2695 p
->kill_without_query
= 1;
2696 if (tem
= Fplist_get (contact
, QCstop
), !NILP (tem
))
2697 pset_command (p
, Qt
);
2700 if (!EQ (p
->command
, Qt
))
2702 FD_SET (fd
, &input_wait_mask
);
2703 FD_SET (fd
, &non_keyboard_wait_mask
);
2706 if (BUFFERP (buffer
))
2708 set_marker_both (p
->mark
, buffer
,
2709 BUF_ZV (XBUFFER (buffer
)),
2710 BUF_ZV_BYTE (XBUFFER (buffer
)));
2713 tem
= Fplist_member (contact
, QCcoding
);
2714 if (!NILP (tem
) && (!CONSP (tem
) || !CONSP (XCDR (tem
))))
2720 val
= XCAR (XCDR (tem
));
2724 else if (!NILP (Vcoding_system_for_read
))
2725 val
= Vcoding_system_for_read
;
2726 else if ((!NILP (buffer
) && NILP (BVAR (XBUFFER (buffer
), enable_multibyte_characters
)))
2727 || (NILP (buffer
) && NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
))))
2729 pset_decode_coding_system (p
, val
);
2734 val
= XCAR (XCDR (tem
));
2738 else if (!NILP (Vcoding_system_for_write
))
2739 val
= Vcoding_system_for_write
;
2740 else if ((!NILP (buffer
) && NILP (BVAR (XBUFFER (buffer
), enable_multibyte_characters
)))
2741 || (NILP (buffer
) && NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
))))
2743 pset_encode_coding_system (p
, val
);
2745 setup_process_coding_systems (proc
);
2746 pset_decoding_buf (p
, empty_unibyte_string
);
2747 p
->decoding_carryover
= 0;
2748 pset_encoding_buf (p
, empty_unibyte_string
);
2749 p
->inherit_coding_system_flag
2750 = !(!NILP (tem
) || NILP (buffer
) || !inherit_process_coding_system
);
2752 Fserial_process_configure (nargs
, args
);
2754 specpdl_ptr
= specpdl
+ specpdl_count
;
2760 /* Create a network stream/datagram client/server process. Treated
2761 exactly like a normal process when reading and writing. Primary
2762 differences are in status display and process deletion. A network
2763 connection has no PID; you cannot signal it. All you can do is
2764 stop/continue it and deactivate/close it via delete-process */
2766 DEFUN ("make-network-process", Fmake_network_process
, Smake_network_process
,
2768 doc
: /* Create and return a network server or client process.
2770 In Emacs, network connections are represented by process objects, so
2771 input and output work as for subprocesses and `delete-process' closes
2772 a network connection. However, a network process has no process id,
2773 it cannot be signaled, and the status codes are different from normal
2776 Arguments are specified as keyword/argument pairs. The following
2777 arguments are defined:
2779 :name NAME -- NAME is name for process. It is modified if necessary
2782 :buffer BUFFER -- BUFFER is the buffer (or buffer-name) to associate
2783 with the process. Process output goes at end of that buffer, unless
2784 you specify an output stream or filter function to handle the output.
2785 BUFFER may be also nil, meaning that this process is not associated
2788 :host HOST -- HOST is name of the host to connect to, or its IP
2789 address. The symbol `local' specifies the local host. If specified
2790 for a server process, it must be a valid name or address for the local
2791 host, and only clients connecting to that address will be accepted.
2793 :service SERVICE -- SERVICE is name of the service desired, or an
2794 integer specifying a port number to connect to. If SERVICE is t,
2795 a random port number is selected for the server. (If Emacs was
2796 compiled with getaddrinfo, a port number can also be specified as a
2797 string, e.g. "80", as well as an integer. This is not portable.)
2799 :type TYPE -- TYPE is the type of connection. The default (nil) is a
2800 stream type connection, `datagram' creates a datagram type connection,
2801 `seqpacket' creates a reliable datagram connection.
2803 :family FAMILY -- FAMILY is the address (and protocol) family for the
2804 service specified by HOST and SERVICE. The default (nil) is to use
2805 whatever address family (IPv4 or IPv6) that is defined for the host
2806 and port number specified by HOST and SERVICE. Other address families
2808 local -- for a local (i.e. UNIX) address specified by SERVICE.
2809 ipv4 -- use IPv4 address family only.
2810 ipv6 -- use IPv6 address family only.
2812 :local ADDRESS -- ADDRESS is the local address used for the connection.
2813 This parameter is ignored when opening a client process. When specified
2814 for a server process, the FAMILY, HOST and SERVICE args are ignored.
2816 :remote ADDRESS -- ADDRESS is the remote partner's address for the
2817 connection. This parameter is ignored when opening a stream server
2818 process. For a datagram server process, it specifies the initial
2819 setting of the remote datagram address. When specified for a client
2820 process, the FAMILY, HOST, and SERVICE args are ignored.
2822 The format of ADDRESS depends on the address family:
2823 - An IPv4 address is represented as an vector of integers [A B C D P]
2824 corresponding to numeric IP address A.B.C.D and port number P.
2825 - A local address is represented as a string with the address in the
2826 local address space.
2827 - An "unsupported family" address is represented by a cons (F . AV)
2828 where F is the family number and AV is a vector containing the socket
2829 address data with one element per address data byte. Do not rely on
2830 this format in portable code, as it may depend on implementation
2831 defined constants, data sizes, and data structure alignment.
2833 :coding CODING -- If CODING is a symbol, it specifies the coding
2834 system used for both reading and writing for this process. If CODING
2835 is a cons (DECODING . ENCODING), DECODING is used for reading, and
2836 ENCODING is used for writing.
2838 :nowait BOOL -- If BOOL is non-nil for a stream type client process,
2839 return without waiting for the connection to complete; instead, the
2840 sentinel function will be called with second arg matching "open" (if
2841 successful) or "failed" when the connect completes. Default is to use
2842 a blocking connect (i.e. wait) for stream type connections.
2844 :noquery BOOL -- Query the user unless BOOL is non-nil, and process is
2845 running when Emacs is exited.
2847 :stop BOOL -- Start process in the `stopped' state if BOOL non-nil.
2848 In the stopped state, a server process does not accept new
2849 connections, and a client process does not handle incoming traffic.
2850 The stopped state is cleared by `continue-process' and set by
2853 :filter FILTER -- Install FILTER as the process filter.
2855 :filter-multibyte BOOL -- If BOOL is non-nil, strings given to the
2856 process filter are multibyte, otherwise they are unibyte.
2857 If this keyword is not specified, the strings are multibyte if
2858 the default value of `enable-multibyte-characters' is non-nil.
2860 :sentinel SENTINEL -- Install SENTINEL as the process sentinel.
2862 :log LOG -- Install LOG as the server process log function. This
2863 function is called when the server accepts a network connection from a
2864 client. The arguments are SERVER, CLIENT, and MESSAGE, where SERVER
2865 is the server process, CLIENT is the new process for the connection,
2866 and MESSAGE is a string.
2868 :plist PLIST -- Install PLIST as the new process' initial plist.
2870 :server QLEN -- if QLEN is non-nil, create a server process for the
2871 specified FAMILY, SERVICE, and connection type (stream or datagram).
2872 If QLEN is an integer, it is used as the max. length of the server's
2873 pending connection queue (also known as the backlog); the default
2874 queue length is 5. Default is to create a client process.
2876 The following network options can be specified for this connection:
2878 :broadcast BOOL -- Allow send and receive of datagram broadcasts.
2879 :dontroute BOOL -- Only send to directly connected hosts.
2880 :keepalive BOOL -- Send keep-alive messages on network stream.
2881 :linger BOOL or TIMEOUT -- Send queued messages before closing.
2882 :oobinline BOOL -- Place out-of-band data in receive data stream.
2883 :priority INT -- Set protocol defined priority for sent packets.
2884 :reuseaddr BOOL -- Allow reusing a recently used local address
2885 (this is allowed by default for a server process).
2886 :bindtodevice NAME -- bind to interface NAME. Using this may require
2887 special privileges on some systems.
2889 Consult the relevant system programmer's manual pages for more
2890 information on using these options.
2893 A server process will listen for and accept connections from clients.
2894 When a client connection is accepted, a new network process is created
2895 for the connection with the following parameters:
2897 - The client's process name is constructed by concatenating the server
2898 process' NAME and a client identification string.
2899 - If the FILTER argument is non-nil, the client process will not get a
2900 separate process buffer; otherwise, the client's process buffer is a newly
2901 created buffer named after the server process' BUFFER name or process
2902 NAME concatenated with the client identification string.
2903 - The connection type and the process filter and sentinel parameters are
2904 inherited from the server process' TYPE, FILTER and SENTINEL.
2905 - The client process' contact info is set according to the client's
2906 addressing information (typically an IP address and a port number).
2907 - The client process' plist is initialized from the server's plist.
2909 Notice that the FILTER and SENTINEL args are never used directly by
2910 the server process. Also, the BUFFER argument is not used directly by
2911 the server process, but via the optional :log function, accepted (and
2912 failed) connections may be logged in the server process' buffer.
2914 The original argument list, modified with the actual connection
2915 information, is available via the `process-contact' function.
2917 usage: (make-network-process &rest ARGS) */)
2918 (ptrdiff_t nargs
, Lisp_Object
*args
)
2921 Lisp_Object contact
;
2922 struct Lisp_Process
*p
;
2923 #ifdef HAVE_GETADDRINFO
2924 struct addrinfo ai
, *res
, *lres
;
2925 struct addrinfo hints
;
2926 const char *portstring
;
2928 #else /* HAVE_GETADDRINFO */
2929 struct _emacs_addrinfo
2935 struct sockaddr
*ai_addr
;
2936 struct _emacs_addrinfo
*ai_next
;
2938 #endif /* HAVE_GETADDRINFO */
2939 struct sockaddr_in address_in
;
2940 #ifdef HAVE_LOCAL_SOCKETS
2941 struct sockaddr_un address_un
;
2946 int s
= -1, outch
, inch
;
2947 struct gcpro gcpro1
;
2948 ptrdiff_t count
= SPECPDL_INDEX ();
2950 Lisp_Object QCaddress
; /* one of QClocal or QCremote */
2952 Lisp_Object name
, buffer
, host
, service
, address
;
2953 Lisp_Object filter
, sentinel
;
2954 int is_non_blocking_client
= 0;
2955 int is_server
= 0, backlog
= 5;
2962 /* Save arguments for process-contact and clone-process. */
2963 contact
= Flist (nargs
, args
);
2967 /* Ensure socket support is loaded if available. */
2968 init_winsock (TRUE
);
2971 /* :type TYPE (nil: stream, datagram */
2972 tem
= Fplist_get (contact
, QCtype
);
2974 socktype
= SOCK_STREAM
;
2975 #ifdef DATAGRAM_SOCKETS
2976 else if (EQ (tem
, Qdatagram
))
2977 socktype
= SOCK_DGRAM
;
2979 #ifdef HAVE_SEQPACKET
2980 else if (EQ (tem
, Qseqpacket
))
2981 socktype
= SOCK_SEQPACKET
;
2984 error ("Unsupported connection type");
2987 tem
= Fplist_get (contact
, QCserver
);
2990 /* Don't support network sockets when non-blocking mode is
2991 not available, since a blocked Emacs is not useful. */
2992 #if !defined (O_NONBLOCK) && !defined (O_NDELAY)
2993 error ("Network servers not supported");
2996 if (TYPE_RANGED_INTEGERP (int, tem
))
2997 backlog
= XINT (tem
);
3001 /* Make QCaddress an alias for :local (server) or :remote (client). */
3002 QCaddress
= is_server
? QClocal
: QCremote
;
3005 if (!is_server
&& socktype
!= SOCK_DGRAM
3006 && (tem
= Fplist_get (contact
, QCnowait
), !NILP (tem
)))
3008 #ifndef NON_BLOCKING_CONNECT
3009 error ("Non-blocking connect not supported");
3011 is_non_blocking_client
= 1;
3015 name
= Fplist_get (contact
, QCname
);
3016 buffer
= Fplist_get (contact
, QCbuffer
);
3017 filter
= Fplist_get (contact
, QCfilter
);
3018 sentinel
= Fplist_get (contact
, QCsentinel
);
3020 CHECK_STRING (name
);
3022 /* Initialize addrinfo structure in case we don't use getaddrinfo. */
3023 ai
.ai_socktype
= socktype
;
3028 /* :local ADDRESS or :remote ADDRESS */
3029 address
= Fplist_get (contact
, QCaddress
);
3030 if (!NILP (address
))
3032 host
= service
= Qnil
;
3034 if (!(ai
.ai_addrlen
= get_lisp_to_sockaddr_size (address
, &family
)))
3035 error ("Malformed :address");
3036 ai
.ai_family
= family
;
3037 ai
.ai_addr
= alloca (ai
.ai_addrlen
);
3038 conv_lisp_to_sockaddr (family
, address
, ai
.ai_addr
, ai
.ai_addrlen
);
3042 /* :family FAMILY -- nil (for Inet), local, or integer. */
3043 tem
= Fplist_get (contact
, QCfamily
);
3046 #if defined (HAVE_GETADDRINFO) && defined (AF_INET6)
3052 #ifdef HAVE_LOCAL_SOCKETS
3053 else if (EQ (tem
, Qlocal
))
3057 else if (EQ (tem
, Qipv6
))
3060 else if (EQ (tem
, Qipv4
))
3062 else if (TYPE_RANGED_INTEGERP (int, tem
))
3063 family
= XINT (tem
);
3065 error ("Unknown address family");
3067 ai
.ai_family
= family
;
3069 /* :service SERVICE -- string, integer (port number), or t (random port). */
3070 service
= Fplist_get (contact
, QCservice
);
3072 /* :host HOST -- hostname, ip address, or 'local for localhost. */
3073 host
= Fplist_get (contact
, QChost
);
3076 if (EQ (host
, Qlocal
))
3077 /* Depending on setup, "localhost" may map to different IPv4 and/or
3078 IPv6 addresses, so it's better to be explicit. (Bug#6781) */
3079 host
= build_string ("127.0.0.1");
3080 CHECK_STRING (host
);
3083 #ifdef HAVE_LOCAL_SOCKETS
3084 if (family
== AF_LOCAL
)
3088 message (":family local ignores the :host \"%s\" property",
3090 contact
= Fplist_put (contact
, QChost
, Qnil
);
3093 CHECK_STRING (service
);
3094 memset (&address_un
, 0, sizeof address_un
);
3095 address_un
.sun_family
= AF_LOCAL
;
3096 if (sizeof address_un
.sun_path
<= SBYTES (service
))
3097 error ("Service name too long");
3098 strcpy (address_un
.sun_path
, SSDATA (service
));
3099 ai
.ai_addr
= (struct sockaddr
*) &address_un
;
3100 ai
.ai_addrlen
= sizeof address_un
;
3105 /* Slow down polling to every ten seconds.
3106 Some kernels have a bug which causes retrying connect to fail
3107 after a connect. Polling can interfere with gethostbyname too. */
3108 #ifdef POLL_FOR_INPUT
3109 if (socktype
!= SOCK_DGRAM
)
3111 record_unwind_protect (unwind_stop_other_atimers
, Qnil
);
3112 bind_polling_period (10);
3116 #ifdef HAVE_GETADDRINFO
3117 /* If we have a host, use getaddrinfo to resolve both host and service.
3118 Otherwise, use getservbyname to lookup the service. */
3122 /* SERVICE can either be a string or int.
3123 Convert to a C string for later use by getaddrinfo. */
3124 if (EQ (service
, Qt
))
3126 else if (INTEGERP (service
))
3128 sprintf (portbuf
, "%"pI
"d", XINT (service
));
3129 portstring
= portbuf
;
3133 CHECK_STRING (service
);
3134 portstring
= SSDATA (service
);
3139 memset (&hints
, 0, sizeof (hints
));
3141 hints
.ai_family
= family
;
3142 hints
.ai_socktype
= socktype
;
3143 hints
.ai_protocol
= 0;
3145 #ifdef HAVE_RES_INIT
3149 ret
= getaddrinfo (SSDATA (host
), portstring
, &hints
, &res
);
3151 #ifdef HAVE_GAI_STRERROR
3152 error ("%s/%s %s", SSDATA (host
), portstring
, gai_strerror (ret
));
3154 error ("%s/%s getaddrinfo error %d", SSDATA (host
), portstring
, ret
);
3160 #endif /* HAVE_GETADDRINFO */
3162 /* We end up here if getaddrinfo is not defined, or in case no hostname
3163 has been specified (e.g. for a local server process). */
3165 if (EQ (service
, Qt
))
3167 else if (INTEGERP (service
))
3168 port
= htons ((unsigned short) XINT (service
));
3171 struct servent
*svc_info
;
3172 CHECK_STRING (service
);
3173 svc_info
= getservbyname (SSDATA (service
),
3174 (socktype
== SOCK_DGRAM
? "udp" : "tcp"));
3176 error ("Unknown service: %s", SDATA (service
));
3177 port
= svc_info
->s_port
;
3180 memset (&address_in
, 0, sizeof address_in
);
3181 address_in
.sin_family
= family
;
3182 address_in
.sin_addr
.s_addr
= INADDR_ANY
;
3183 address_in
.sin_port
= port
;
3185 #ifndef HAVE_GETADDRINFO
3188 struct hostent
*host_info_ptr
;
3190 /* gethostbyname may fail with TRY_AGAIN, but we don't honor that,
3191 as it may `hang' Emacs for a very long time. */
3195 #ifdef HAVE_RES_INIT
3199 host_info_ptr
= gethostbyname (SDATA (host
));
3204 memcpy (&address_in
.sin_addr
, host_info_ptr
->h_addr
,
3205 host_info_ptr
->h_length
);
3206 family
= host_info_ptr
->h_addrtype
;
3207 address_in
.sin_family
= family
;
3210 /* Attempt to interpret host as numeric inet address */
3212 unsigned long numeric_addr
;
3213 numeric_addr
= inet_addr (SSDATA (host
));
3214 if (numeric_addr
== -1)
3215 error ("Unknown host \"%s\"", SDATA (host
));
3217 memcpy (&address_in
.sin_addr
, &numeric_addr
,
3218 sizeof (address_in
.sin_addr
));
3222 #endif /* not HAVE_GETADDRINFO */
3224 ai
.ai_family
= family
;
3225 ai
.ai_addr
= (struct sockaddr
*) &address_in
;
3226 ai
.ai_addrlen
= sizeof address_in
;
3230 /* Do this in case we never enter the for-loop below. */
3231 count1
= SPECPDL_INDEX ();
3234 for (lres
= res
; lres
; lres
= lres
->ai_next
)
3243 s
= socket (lres
->ai_family
, lres
->ai_socktype
, lres
->ai_protocol
);
3250 #ifdef DATAGRAM_SOCKETS
3251 if (!is_server
&& socktype
== SOCK_DGRAM
)
3253 #endif /* DATAGRAM_SOCKETS */
3255 #ifdef NON_BLOCKING_CONNECT
3256 if (is_non_blocking_client
)
3259 ret
= fcntl (s
, F_SETFL
, O_NONBLOCK
);
3261 ret
= fcntl (s
, F_SETFL
, O_NDELAY
);
3273 /* Make us close S if quit. */
3274 record_unwind_protect (close_file_unwind
, make_number (s
));
3276 /* Parse network options in the arg list.
3277 We simply ignore anything which isn't a known option (including other keywords).
3278 An error is signaled if setting a known option fails. */
3279 for (optn
= optbits
= 0; optn
< nargs
-1; optn
+= 2)
3280 optbits
|= set_socket_option (s
, args
[optn
], args
[optn
+1]);
3284 /* Configure as a server socket. */
3286 /* SO_REUSEADDR = 1 is default for server sockets; must specify
3287 explicit :reuseaddr key to override this. */
3288 #ifdef HAVE_LOCAL_SOCKETS
3289 if (family
!= AF_LOCAL
)
3291 if (!(optbits
& (1 << OPIX_REUSEADDR
)))
3294 if (setsockopt (s
, SOL_SOCKET
, SO_REUSEADDR
, &optval
, sizeof optval
))
3295 report_file_error ("Cannot set reuse option on server socket", Qnil
);
3298 if (bind (s
, lres
->ai_addr
, lres
->ai_addrlen
))
3299 report_file_error ("Cannot bind server socket", Qnil
);
3301 #ifdef HAVE_GETSOCKNAME
3302 if (EQ (service
, Qt
))
3304 struct sockaddr_in sa1
;
3305 socklen_t len1
= sizeof (sa1
);
3306 if (getsockname (s
, (struct sockaddr
*)&sa1
, &len1
) == 0)
3308 ((struct sockaddr_in
*)(lres
->ai_addr
))->sin_port
= sa1
.sin_port
;
3309 service
= make_number (ntohs (sa1
.sin_port
));
3310 contact
= Fplist_put (contact
, QCservice
, service
);
3315 if (socktype
!= SOCK_DGRAM
&& listen (s
, backlog
))
3316 report_file_error ("Cannot listen on server socket", Qnil
);
3324 ret
= connect (s
, lres
->ai_addr
, lres
->ai_addrlen
);
3327 if (ret
== 0 || xerrno
== EISCONN
)
3329 /* The unwind-protect will be discarded afterwards.
3330 Likewise for immediate_quit. */
3334 #ifdef NON_BLOCKING_CONNECT
3336 if (is_non_blocking_client
&& xerrno
== EINPROGRESS
)
3340 if (is_non_blocking_client
&& xerrno
== EWOULDBLOCK
)
3347 if (xerrno
== EINTR
)
3349 /* Unlike most other syscalls connect() cannot be called
3350 again. (That would return EALREADY.) The proper way to
3351 wait for completion is pselect(). */
3359 sc
= pselect (s
+ 1, NULL
, &fdset
, NULL
, NULL
, NULL
);
3365 report_file_error ("select failed", Qnil
);
3369 len
= sizeof xerrno
;
3370 eassert (FD_ISSET (s
, &fdset
));
3371 if (getsockopt (s
, SOL_SOCKET
, SO_ERROR
, &xerrno
, &len
) == -1)
3372 report_file_error ("getsockopt failed", Qnil
);
3374 errno
= xerrno
, report_file_error ("error during connect", Qnil
);
3378 #endif /* !WINDOWSNT */
3382 /* Discard the unwind protect closing S. */
3383 specpdl_ptr
= specpdl
+ count1
;
3388 if (xerrno
== EINTR
)
3395 #ifdef DATAGRAM_SOCKETS
3396 if (socktype
== SOCK_DGRAM
)
3398 if (datagram_address
[s
].sa
)
3400 datagram_address
[s
].sa
= xmalloc (lres
->ai_addrlen
);
3401 datagram_address
[s
].len
= lres
->ai_addrlen
;
3405 memset (datagram_address
[s
].sa
, 0, lres
->ai_addrlen
);
3406 if (remote
= Fplist_get (contact
, QCremote
), !NILP (remote
))
3409 rlen
= get_lisp_to_sockaddr_size (remote
, &rfamily
);
3410 if (rfamily
== lres
->ai_family
&& rlen
== lres
->ai_addrlen
)
3411 conv_lisp_to_sockaddr (rfamily
, remote
,
3412 datagram_address
[s
].sa
, rlen
);
3416 memcpy (datagram_address
[s
].sa
, lres
->ai_addr
, lres
->ai_addrlen
);
3419 contact
= Fplist_put (contact
, QCaddress
,
3420 conv_sockaddr_to_lisp (lres
->ai_addr
, lres
->ai_addrlen
));
3421 #ifdef HAVE_GETSOCKNAME
3424 struct sockaddr_in sa1
;
3425 socklen_t len1
= sizeof (sa1
);
3426 if (getsockname (s
, (struct sockaddr
*)&sa1
, &len1
) == 0)
3427 contact
= Fplist_put (contact
, QClocal
,
3428 conv_sockaddr_to_lisp ((struct sockaddr
*)&sa1
, len1
));
3435 #ifdef HAVE_GETADDRINFO
3444 /* Discard the unwind protect for closing S, if any. */
3445 specpdl_ptr
= specpdl
+ count1
;
3447 /* Unwind bind_polling_period and request_sigio. */
3448 unbind_to (count
, Qnil
);
3452 /* If non-blocking got this far - and failed - assume non-blocking is
3453 not supported after all. This is probably a wrong assumption, but
3454 the normal blocking calls to open-network-stream handles this error
3456 if (is_non_blocking_client
)
3461 report_file_error ("make server process failed", contact
);
3463 report_file_error ("make client process failed", contact
);
3470 buffer
= Fget_buffer_create (buffer
);
3471 proc
= make_process (name
);
3473 chan_process
[inch
] = proc
;
3476 fcntl (inch
, F_SETFL
, O_NONBLOCK
);
3479 fcntl (inch
, F_SETFL
, O_NDELAY
);
3483 p
= XPROCESS (proc
);
3485 pset_childp (p
, contact
);
3486 pset_plist (p
, Fcopy_sequence (Fplist_get (contact
, QCplist
)));
3487 pset_type (p
, Qnetwork
);
3489 pset_buffer (p
, buffer
);
3490 pset_sentinel (p
, sentinel
);
3491 pset_filter (p
, filter
);
3492 pset_log (p
, Fplist_get (contact
, QClog
));
3493 if (tem
= Fplist_get (contact
, QCnoquery
), !NILP (tem
))
3494 p
->kill_without_query
= 1;
3495 if ((tem
= Fplist_get (contact
, QCstop
), !NILP (tem
)))
3496 pset_command (p
, Qt
);
3500 if (is_server
&& socktype
!= SOCK_DGRAM
)
3501 pset_status (p
, Qlisten
);
3503 /* Make the process marker point into the process buffer (if any). */
3504 if (BUFFERP (buffer
))
3505 set_marker_both (p
->mark
, buffer
,
3506 BUF_ZV (XBUFFER (buffer
)),
3507 BUF_ZV_BYTE (XBUFFER (buffer
)));
3509 #ifdef NON_BLOCKING_CONNECT
3510 if (is_non_blocking_client
)
3512 /* We may get here if connect did succeed immediately. However,
3513 in that case, we still need to signal this like a non-blocking
3515 pset_status (p
, Qconnect
);
3516 if (!FD_ISSET (inch
, &connect_wait_mask
))
3518 FD_SET (inch
, &connect_wait_mask
);
3519 FD_SET (inch
, &write_mask
);
3520 num_pending_connects
++;
3525 /* A server may have a client filter setting of Qt, but it must
3526 still listen for incoming connects unless it is stopped. */
3527 if ((!EQ (p
->filter
, Qt
) && !EQ (p
->command
, Qt
))
3528 || (EQ (p
->status
, Qlisten
) && NILP (p
->command
)))
3530 FD_SET (inch
, &input_wait_mask
);
3531 FD_SET (inch
, &non_keyboard_wait_mask
);
3534 if (inch
> max_process_desc
)
3535 max_process_desc
= inch
;
3537 tem
= Fplist_member (contact
, QCcoding
);
3538 if (!NILP (tem
) && (!CONSP (tem
) || !CONSP (XCDR (tem
))))
3539 tem
= Qnil
; /* No error message (too late!). */
3542 /* Setup coding systems for communicating with the network stream. */
3543 struct gcpro gcpro1
;
3544 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
3545 Lisp_Object coding_systems
= Qt
;
3546 Lisp_Object fargs
[5], val
;
3550 val
= XCAR (XCDR (tem
));
3554 else if (!NILP (Vcoding_system_for_read
))
3555 val
= Vcoding_system_for_read
;
3556 else if ((!NILP (buffer
) && NILP (BVAR (XBUFFER (buffer
), enable_multibyte_characters
)))
3557 || (NILP (buffer
) && NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
))))
3558 /* We dare not decode end-of-line format by setting VAL to
3559 Qraw_text, because the existing Emacs Lisp libraries
3560 assume that they receive bare code including a sequence of
3565 if (NILP (host
) || NILP (service
))
3566 coding_systems
= Qnil
;
3569 fargs
[0] = Qopen_network_stream
, fargs
[1] = name
,
3570 fargs
[2] = buffer
, fargs
[3] = host
, fargs
[4] = service
;
3572 coding_systems
= Ffind_operation_coding_system (5, fargs
);
3575 if (CONSP (coding_systems
))
3576 val
= XCAR (coding_systems
);
3577 else if (CONSP (Vdefault_process_coding_system
))
3578 val
= XCAR (Vdefault_process_coding_system
);
3582 pset_decode_coding_system (p
, val
);
3586 val
= XCAR (XCDR (tem
));
3590 else if (!NILP (Vcoding_system_for_write
))
3591 val
= Vcoding_system_for_write
;
3592 else if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3596 if (EQ (coding_systems
, Qt
))
3598 if (NILP (host
) || NILP (service
))
3599 coding_systems
= Qnil
;
3602 fargs
[0] = Qopen_network_stream
, fargs
[1] = name
,
3603 fargs
[2] = buffer
, fargs
[3] = host
, fargs
[4] = service
;
3605 coding_systems
= Ffind_operation_coding_system (5, fargs
);
3609 if (CONSP (coding_systems
))
3610 val
= XCDR (coding_systems
);
3611 else if (CONSP (Vdefault_process_coding_system
))
3612 val
= XCDR (Vdefault_process_coding_system
);
3616 pset_encode_coding_system (p
, val
);
3618 setup_process_coding_systems (proc
);
3620 pset_decoding_buf (p
, empty_unibyte_string
);
3621 p
->decoding_carryover
= 0;
3622 pset_encoding_buf (p
, empty_unibyte_string
);
3624 p
->inherit_coding_system_flag
3625 = !(!NILP (tem
) || NILP (buffer
) || !inherit_process_coding_system
);
3632 #if defined (HAVE_NET_IF_H)
3635 DEFUN ("network-interface-list", Fnetwork_interface_list
, Snetwork_interface_list
, 0, 0, 0,
3636 doc
: /* Return an alist of all network interfaces and their network address.
3637 Each element is a cons, the car of which is a string containing the
3638 interface name, and the cdr is the network address in internal
3639 format; see the description of ADDRESS in `make-network-process'. */)
3642 struct ifconf ifconf
;
3643 struct ifreq
*ifreq
;
3645 ptrdiff_t buf_size
= 512;
3649 s
= socket (AF_INET
, SOCK_STREAM
, 0);
3655 buf
= xpalloc (buf
, &buf_size
, 1, INT_MAX
, 1);
3656 ifconf
.ifc_buf
= buf
;
3657 ifconf
.ifc_len
= buf_size
;
3658 if (ioctl (s
, SIOCGIFCONF
, &ifconf
))
3665 while (ifconf
.ifc_len
== buf_size
);
3670 ifreq
= ifconf
.ifc_req
;
3671 while ((char *) ifreq
< (char *) ifconf
.ifc_req
+ ifconf
.ifc_len
)
3673 struct ifreq
*ifq
= ifreq
;
3674 #ifdef HAVE_STRUCT_IFREQ_IFR_ADDR_SA_LEN
3675 #define SIZEOF_IFREQ(sif) \
3676 ((sif)->ifr_addr.sa_len < sizeof (struct sockaddr) \
3677 ? sizeof (*(sif)) : sizeof ((sif)->ifr_name) + (sif)->ifr_addr.sa_len)
3679 int len
= SIZEOF_IFREQ (ifq
);
3681 int len
= sizeof (*ifreq
);
3683 char namebuf
[sizeof (ifq
->ifr_name
) + 1];
3685 ifreq
= (struct ifreq
*) ((char *) ifreq
+ len
);
3687 if (ifq
->ifr_addr
.sa_family
!= AF_INET
)
3690 memcpy (namebuf
, ifq
->ifr_name
, sizeof (ifq
->ifr_name
));
3691 namebuf
[sizeof (ifq
->ifr_name
)] = 0;
3692 res
= Fcons (Fcons (build_string (namebuf
),
3693 conv_sockaddr_to_lisp (&ifq
->ifr_addr
,
3694 sizeof (struct sockaddr
))),
3701 #endif /* SIOCGIFCONF */
3703 #if defined (SIOCGIFADDR) || defined (SIOCGIFHWADDR) || defined (SIOCGIFFLAGS)
3707 const char *flag_sym
;
3710 static const struct ifflag_def ifflag_table
[] = {
3714 #ifdef IFF_BROADCAST
3715 { IFF_BROADCAST
, "broadcast" },
3718 { IFF_DEBUG
, "debug" },
3721 { IFF_LOOPBACK
, "loopback" },
3723 #ifdef IFF_POINTOPOINT
3724 { IFF_POINTOPOINT
, "pointopoint" },
3727 { IFF_RUNNING
, "running" },
3730 { IFF_NOARP
, "noarp" },
3733 { IFF_PROMISC
, "promisc" },
3735 #ifdef IFF_NOTRAILERS
3736 #ifdef NS_IMPL_COCOA
3737 /* Really means smart, notrailers is obsolete */
3738 { IFF_NOTRAILERS
, "smart" },
3740 { IFF_NOTRAILERS
, "notrailers" },
3744 { IFF_ALLMULTI
, "allmulti" },
3747 { IFF_MASTER
, "master" },
3750 { IFF_SLAVE
, "slave" },
3752 #ifdef IFF_MULTICAST
3753 { IFF_MULTICAST
, "multicast" },
3756 { IFF_PORTSEL
, "portsel" },
3758 #ifdef IFF_AUTOMEDIA
3759 { IFF_AUTOMEDIA
, "automedia" },
3762 { IFF_DYNAMIC
, "dynamic" },
3765 { IFF_OACTIVE
, "oactive" }, /* OpenBSD: transmission in progress */
3768 { IFF_SIMPLEX
, "simplex" }, /* OpenBSD: can't hear own transmissions */
3771 { IFF_LINK0
, "link0" }, /* OpenBSD: per link layer defined bit */
3774 { IFF_LINK1
, "link1" }, /* OpenBSD: per link layer defined bit */
3777 { IFF_LINK2
, "link2" }, /* OpenBSD: per link layer defined bit */
3782 DEFUN ("network-interface-info", Fnetwork_interface_info
, Snetwork_interface_info
, 1, 1, 0,
3783 doc
: /* Return information about network interface named IFNAME.
3784 The return value is a list (ADDR BCAST NETMASK HWADDR FLAGS),
3785 where ADDR is the layer 3 address, BCAST is the layer 3 broadcast address,
3786 NETMASK is the layer 3 network mask, HWADDR is the layer 2 address, and
3787 FLAGS is the current flags of the interface. */)
3788 (Lisp_Object ifname
)
3791 Lisp_Object res
= Qnil
;
3795 #if (! (defined SIOCGIFHWADDR && defined HAVE_STRUCT_IFREQ_IFR_HWADDR) \
3796 && defined HAVE_GETIFADDRS && defined LLADDR)
3797 struct ifaddrs
*ifap
;
3800 CHECK_STRING (ifname
);
3802 if (sizeof rq
.ifr_name
<= SBYTES (ifname
))
3803 error ("interface name too long");
3804 strcpy (rq
.ifr_name
, SSDATA (ifname
));
3806 s
= socket (AF_INET
, SOCK_STREAM
, 0);
3811 #if defined (SIOCGIFFLAGS) && defined (HAVE_STRUCT_IFREQ_IFR_FLAGS)
3812 if (ioctl (s
, SIOCGIFFLAGS
, &rq
) == 0)
3814 int flags
= rq
.ifr_flags
;
3815 const struct ifflag_def
*fp
;
3818 /* If flags is smaller than int (i.e. short) it may have the high bit set
3819 due to IFF_MULTICAST. In that case, sign extending it into
3821 if (flags
< 0 && sizeof (rq
.ifr_flags
) < sizeof (flags
))
3822 flags
= (unsigned short) rq
.ifr_flags
;
3825 for (fp
= ifflag_table
; flags
!= 0 && fp
->flag_sym
; fp
++)
3827 if (flags
& fp
->flag_bit
)
3829 elt
= Fcons (intern (fp
->flag_sym
), elt
);
3830 flags
-= fp
->flag_bit
;
3833 for (fnum
= 0; flags
&& fnum
< 32; flags
>>= 1, fnum
++)
3837 elt
= Fcons (make_number (fnum
), elt
);
3842 res
= Fcons (elt
, res
);
3845 #if defined (SIOCGIFHWADDR) && defined (HAVE_STRUCT_IFREQ_IFR_HWADDR)
3846 if (ioctl (s
, SIOCGIFHWADDR
, &rq
) == 0)
3848 Lisp_Object hwaddr
= Fmake_vector (make_number (6), Qnil
);
3849 register struct Lisp_Vector
*p
= XVECTOR (hwaddr
);
3853 for (n
= 0; n
< 6; n
++)
3854 p
->contents
[n
] = make_number (((unsigned char *)&rq
.ifr_hwaddr
.sa_data
[0])[n
]);
3855 elt
= Fcons (make_number (rq
.ifr_hwaddr
.sa_family
), hwaddr
);
3857 #elif defined (HAVE_GETIFADDRS) && defined (LLADDR)
3858 if (getifaddrs (&ifap
) != -1)
3860 Lisp_Object hwaddr
= Fmake_vector (make_number (6), Qnil
);
3861 register struct Lisp_Vector
*p
= XVECTOR (hwaddr
);
3864 for (it
= ifap
; it
!= NULL
; it
= it
->ifa_next
)
3866 struct sockaddr_dl
*sdl
= (struct sockaddr_dl
*) it
->ifa_addr
;
3867 unsigned char linkaddr
[6];
3870 if (it
->ifa_addr
->sa_family
!= AF_LINK
3871 || strcmp (it
->ifa_name
, SSDATA (ifname
)) != 0
3872 || sdl
->sdl_alen
!= 6)
3875 memcpy (linkaddr
, LLADDR (sdl
), sdl
->sdl_alen
);
3876 for (n
= 0; n
< 6; n
++)
3877 p
->contents
[n
] = make_number (linkaddr
[n
]);
3879 elt
= Fcons (make_number (it
->ifa_addr
->sa_family
), hwaddr
);
3883 #ifdef HAVE_FREEIFADDRS
3887 #endif /* HAVE_GETIFADDRS && LLADDR */
3889 res
= Fcons (elt
, res
);
3892 #if defined (SIOCGIFNETMASK) && (defined (HAVE_STRUCT_IFREQ_IFR_NETMASK) || defined (HAVE_STRUCT_IFREQ_IFR_ADDR))
3893 if (ioctl (s
, SIOCGIFNETMASK
, &rq
) == 0)
3896 #ifdef HAVE_STRUCT_IFREQ_IFR_NETMASK
3897 elt
= conv_sockaddr_to_lisp (&rq
.ifr_netmask
, sizeof (rq
.ifr_netmask
));
3899 elt
= conv_sockaddr_to_lisp (&rq
.ifr_addr
, sizeof (rq
.ifr_addr
));
3903 res
= Fcons (elt
, res
);
3906 #if defined (SIOCGIFBRDADDR) && defined (HAVE_STRUCT_IFREQ_IFR_BROADADDR)
3907 if (ioctl (s
, SIOCGIFBRDADDR
, &rq
) == 0)
3910 elt
= conv_sockaddr_to_lisp (&rq
.ifr_broadaddr
, sizeof (rq
.ifr_broadaddr
));
3913 res
= Fcons (elt
, res
);
3916 #if defined (SIOCGIFADDR) && defined (HAVE_STRUCT_IFREQ_IFR_ADDR)
3917 if (ioctl (s
, SIOCGIFADDR
, &rq
) == 0)
3920 elt
= conv_sockaddr_to_lisp (&rq
.ifr_addr
, sizeof (rq
.ifr_addr
));
3923 res
= Fcons (elt
, res
);
3927 return any
? res
: Qnil
;
3930 #endif /* defined (HAVE_NET_IF_H) */
3932 /* Turn off input and output for process PROC. */
3935 deactivate_process (Lisp_Object proc
)
3937 register int inchannel
, outchannel
;
3938 register struct Lisp_Process
*p
= XPROCESS (proc
);
3941 /* Delete GnuTLS structures in PROC, if any. */
3942 emacs_gnutls_deinit (proc
);
3943 #endif /* HAVE_GNUTLS */
3945 inchannel
= p
->infd
;
3946 outchannel
= p
->outfd
;
3948 #ifdef ADAPTIVE_READ_BUFFERING
3949 if (p
->read_output_delay
> 0)
3951 if (--process_output_delay_count
< 0)
3952 process_output_delay_count
= 0;
3953 p
->read_output_delay
= 0;
3954 p
->read_output_skip
= 0;
3960 /* Beware SIGCHLD hereabouts. */
3961 flush_pending_output (inchannel
);
3962 emacs_close (inchannel
);
3963 if (outchannel
>= 0 && outchannel
!= inchannel
)
3964 emacs_close (outchannel
);
3968 #ifdef DATAGRAM_SOCKETS
3969 if (DATAGRAM_CHAN_P (inchannel
))
3971 xfree (datagram_address
[inchannel
].sa
);
3972 datagram_address
[inchannel
].sa
= 0;
3973 datagram_address
[inchannel
].len
= 0;
3976 chan_process
[inchannel
] = Qnil
;
3977 FD_CLR (inchannel
, &input_wait_mask
);
3978 FD_CLR (inchannel
, &non_keyboard_wait_mask
);
3979 #ifdef NON_BLOCKING_CONNECT
3980 if (FD_ISSET (inchannel
, &connect_wait_mask
))
3982 FD_CLR (inchannel
, &connect_wait_mask
);
3983 FD_CLR (inchannel
, &write_mask
);
3984 if (--num_pending_connects
< 0)
3988 if (inchannel
== max_process_desc
)
3991 /* We just closed the highest-numbered process input descriptor,
3992 so recompute the highest-numbered one now. */
3993 max_process_desc
= 0;
3994 for (i
= 0; i
< MAXDESC
; i
++)
3995 if (!NILP (chan_process
[i
]))
3996 max_process_desc
= i
;
4002 DEFUN ("accept-process-output", Faccept_process_output
, Saccept_process_output
,
4004 doc
: /* Allow any pending output from subprocesses to be read by Emacs.
4005 It is read into the process' buffers or given to their filter functions.
4006 Non-nil arg PROCESS means do not return until some output has been received
4009 Non-nil second arg SECONDS and third arg MILLISEC are number of seconds
4010 and milliseconds to wait; return after that much time whether or not
4011 there is any subprocess output. If SECONDS is a floating point number,
4012 it specifies a fractional number of seconds to wait.
4013 The MILLISEC argument is obsolete and should be avoided.
4015 If optional fourth arg JUST-THIS-ONE is non-nil, only accept output
4016 from PROCESS, suspending reading output from other processes.
4017 If JUST-THIS-ONE is an integer, don't run any timers either.
4018 Return non-nil if we received any output before the timeout expired. */)
4019 (register Lisp_Object process
, Lisp_Object seconds
, Lisp_Object millisec
, Lisp_Object just_this_one
)
4024 if (! NILP (process
))
4025 CHECK_PROCESS (process
);
4027 just_this_one
= Qnil
;
4029 if (!NILP (millisec
))
4030 { /* Obsolete calling convention using integers rather than floats. */
4031 CHECK_NUMBER (millisec
);
4033 seconds
= make_float (XINT (millisec
) / 1000.0);
4036 CHECK_NUMBER (seconds
);
4037 seconds
= make_float (XINT (millisec
) / 1000.0 + XINT (seconds
));
4044 if (!NILP (seconds
))
4046 if (INTEGERP (seconds
))
4048 if (0 < XINT (seconds
))
4050 secs
= XINT (seconds
);
4054 else if (FLOATP (seconds
))
4056 if (0 < XFLOAT_DATA (seconds
))
4058 EMACS_TIME t
= EMACS_TIME_FROM_DOUBLE (XFLOAT_DATA (seconds
));
4059 secs
= min (EMACS_SECS (t
), WAIT_READING_MAX
);
4060 nsecs
= EMACS_NSECS (t
);
4064 wrong_type_argument (Qnumberp
, seconds
);
4066 else if (! NILP (process
))
4070 (wait_reading_process_output (secs
, nsecs
, 0, 0,
4072 !NILP (process
) ? XPROCESS (process
) : NULL
,
4073 NILP (just_this_one
) ? 0 :
4074 !INTEGERP (just_this_one
) ? 1 : -1)
4078 /* Accept a connection for server process SERVER on CHANNEL. */
4080 static int connect_counter
= 0;
4083 server_accept_connection (Lisp_Object server
, int channel
)
4085 Lisp_Object proc
, caller
, name
, buffer
;
4086 Lisp_Object contact
, host
, service
;
4087 struct Lisp_Process
*ps
= XPROCESS (server
);
4088 struct Lisp_Process
*p
;
4092 struct sockaddr_in in
;
4094 struct sockaddr_in6 in6
;
4096 #ifdef HAVE_LOCAL_SOCKETS
4097 struct sockaddr_un un
;
4100 socklen_t len
= sizeof saddr
;
4102 s
= accept (channel
, &saddr
.sa
, &len
);
4111 if (code
== EWOULDBLOCK
)
4115 if (!NILP (ps
->log
))
4116 call3 (ps
->log
, server
, Qnil
,
4117 concat3 (build_string ("accept failed with code"),
4118 Fnumber_to_string (make_number (code
)),
4119 build_string ("\n")));
4125 /* Setup a new process to handle the connection. */
4127 /* Generate a unique identification of the caller, and build contact
4128 information for this process. */
4131 switch (saddr
.sa
.sa_family
)
4135 Lisp_Object args
[5];
4136 unsigned char *ip
= (unsigned char *)&saddr
.in
.sin_addr
.s_addr
;
4137 args
[0] = build_string ("%d.%d.%d.%d");
4138 args
[1] = make_number (*ip
++);
4139 args
[2] = make_number (*ip
++);
4140 args
[3] = make_number (*ip
++);
4141 args
[4] = make_number (*ip
++);
4142 host
= Fformat (5, args
);
4143 service
= make_number (ntohs (saddr
.in
.sin_port
));
4145 args
[0] = build_string (" <%s:%d>");
4148 caller
= Fformat (3, args
);
4155 Lisp_Object args
[9];
4156 uint16_t *ip6
= (uint16_t *)&saddr
.in6
.sin6_addr
;
4158 args
[0] = build_string ("%x:%x:%x:%x:%x:%x:%x:%x");
4159 for (i
= 0; i
< 8; i
++)
4160 args
[i
+1] = make_number (ntohs (ip6
[i
]));
4161 host
= Fformat (9, args
);
4162 service
= make_number (ntohs (saddr
.in
.sin_port
));
4164 args
[0] = build_string (" <[%s]:%d>");
4167 caller
= Fformat (3, args
);
4172 #ifdef HAVE_LOCAL_SOCKETS
4176 caller
= Fnumber_to_string (make_number (connect_counter
));
4177 caller
= concat3 (build_string (" <"), caller
, build_string (">"));
4181 /* Create a new buffer name for this process if it doesn't have a
4182 filter. The new buffer name is based on the buffer name or
4183 process name of the server process concatenated with the caller
4186 if (!NILP (ps
->filter
) && !EQ (ps
->filter
, Qt
))
4190 buffer
= ps
->buffer
;
4192 buffer
= Fbuffer_name (buffer
);
4197 buffer
= concat2 (buffer
, caller
);
4198 buffer
= Fget_buffer_create (buffer
);
4202 /* Generate a unique name for the new server process. Combine the
4203 server process name with the caller identification. */
4205 name
= concat2 (ps
->name
, caller
);
4206 proc
= make_process (name
);
4208 chan_process
[s
] = proc
;
4211 fcntl (s
, F_SETFL
, O_NONBLOCK
);
4214 fcntl (s
, F_SETFL
, O_NDELAY
);
4218 p
= XPROCESS (proc
);
4220 /* Build new contact information for this setup. */
4221 contact
= Fcopy_sequence (ps
->childp
);
4222 contact
= Fplist_put (contact
, QCserver
, Qnil
);
4223 contact
= Fplist_put (contact
, QChost
, host
);
4224 if (!NILP (service
))
4225 contact
= Fplist_put (contact
, QCservice
, service
);
4226 contact
= Fplist_put (contact
, QCremote
,
4227 conv_sockaddr_to_lisp (&saddr
.sa
, len
));
4228 #ifdef HAVE_GETSOCKNAME
4230 if (getsockname (s
, &saddr
.sa
, &len
) == 0)
4231 contact
= Fplist_put (contact
, QClocal
,
4232 conv_sockaddr_to_lisp (&saddr
.sa
, len
));
4235 pset_childp (p
, contact
);
4236 pset_plist (p
, Fcopy_sequence (ps
->plist
));
4237 pset_type (p
, Qnetwork
);
4239 pset_buffer (p
, buffer
);
4240 pset_sentinel (p
, ps
->sentinel
);
4241 pset_filter (p
, ps
->filter
);
4242 pset_command (p
, Qnil
);
4246 pset_status (p
, Qrun
);
4248 /* Client processes for accepted connections are not stopped initially. */
4249 if (!EQ (p
->filter
, Qt
))
4251 FD_SET (s
, &input_wait_mask
);
4252 FD_SET (s
, &non_keyboard_wait_mask
);
4255 if (s
> max_process_desc
)
4256 max_process_desc
= s
;
4258 /* Setup coding system for new process based on server process.
4259 This seems to be the proper thing to do, as the coding system
4260 of the new process should reflect the settings at the time the
4261 server socket was opened; not the current settings. */
4263 pset_decode_coding_system (p
, ps
->decode_coding_system
);
4264 pset_encode_coding_system (p
, ps
->encode_coding_system
);
4265 setup_process_coding_systems (proc
);
4267 pset_decoding_buf (p
, empty_unibyte_string
);
4268 p
->decoding_carryover
= 0;
4269 pset_encoding_buf (p
, empty_unibyte_string
);
4271 p
->inherit_coding_system_flag
4272 = (NILP (buffer
) ? 0 : ps
->inherit_coding_system_flag
);
4274 if (!NILP (ps
->log
))
4275 call3 (ps
->log
, server
, proc
,
4276 concat3 (build_string ("accept from "),
4277 (STRINGP (host
) ? host
: build_string ("-")),
4278 build_string ("\n")));
4280 if (!NILP (p
->sentinel
))
4281 exec_sentinel (proc
,
4282 concat3 (build_string ("open from "),
4283 (STRINGP (host
) ? host
: build_string ("-")),
4284 build_string ("\n")));
4287 /* This variable is different from waiting_for_input in keyboard.c.
4288 It is used to communicate to a lisp process-filter/sentinel (via the
4289 function Fwaiting_for_user_input_p below) whether Emacs was waiting
4290 for user-input when that process-filter was called.
4291 waiting_for_input cannot be used as that is by definition 0 when
4292 lisp code is being evalled.
4293 This is also used in record_asynch_buffer_change.
4294 For that purpose, this must be 0
4295 when not inside wait_reading_process_output. */
4296 static int waiting_for_user_input_p
;
4299 wait_reading_process_output_unwind (Lisp_Object data
)
4301 waiting_for_user_input_p
= XINT (data
);
4305 /* This is here so breakpoints can be put on it. */
4307 wait_reading_process_output_1 (void)
4311 /* Read and dispose of subprocess output while waiting for timeout to
4312 elapse and/or keyboard input to be available.
4316 If negative, gobble data immediately available but don't wait for any.
4319 an additional duration to wait, measured in nanoseconds
4320 If TIME_LIMIT is zero, then:
4321 If NSECS == 0, there is no limit.
4322 If NSECS > 0, the timeout consists of NSECS only.
4323 If NSECS < 0, gobble data immediately, as if TIME_LIMIT were negative.
4326 0 to ignore keyboard input, or
4327 1 to return when input is available, or
4328 -1 meaning caller will actually read the input, so don't throw to
4329 the quit handler, or
4331 DO_DISPLAY != 0 means redisplay should be done to show subprocess
4332 output that arrives.
4334 If WAIT_FOR_CELL is a cons cell, wait until its car is non-nil
4335 (and gobble terminal input into the buffer if any arrives).
4337 If WAIT_PROC is specified, wait until something arrives from that
4338 process. The return value is true if we read some input from
4341 If JUST_WAIT_PROC is non-nil, handle only output from WAIT_PROC
4342 (suspending output from other processes). A negative value
4343 means don't run any timers either.
4345 If WAIT_PROC is specified, then the function returns true if we
4346 received input from that process before the timeout elapsed.
4347 Otherwise, return true if we received input from any process. */
4350 wait_reading_process_output (intmax_t time_limit
, int nsecs
, int read_kbd
,
4352 Lisp_Object wait_for_cell
,
4353 struct Lisp_Process
*wait_proc
, int just_wait_proc
)
4355 register int channel
, nfds
;
4356 SELECT_TYPE Available
;
4357 SELECT_TYPE Writeok
;
4359 int check_delay
, no_avail
;
4362 EMACS_TIME timeout
, end_time
;
4363 int wait_channel
= -1;
4364 int got_some_input
= 0;
4365 ptrdiff_t count
= SPECPDL_INDEX ();
4367 FD_ZERO (&Available
);
4370 if (time_limit
== 0 && nsecs
== 0 && wait_proc
&& !NILP (Vinhibit_quit
)
4371 && !(CONSP (wait_proc
->status
)
4372 && EQ (XCAR (wait_proc
->status
), Qexit
)))
4373 message ("Blocking call to accept-process-output with quit inhibited!!");
4375 /* If wait_proc is a process to watch, set wait_channel accordingly. */
4376 if (wait_proc
!= NULL
)
4377 wait_channel
= wait_proc
->infd
;
4379 record_unwind_protect (wait_reading_process_output_unwind
,
4380 make_number (waiting_for_user_input_p
));
4381 waiting_for_user_input_p
= read_kbd
;
4388 else if (TYPE_MAXIMUM (time_t) < time_limit
)
4389 time_limit
= TYPE_MAXIMUM (time_t);
4391 /* Since we may need to wait several times,
4392 compute the absolute time to return at. */
4393 if (time_limit
|| 0 < nsecs
)
4395 timeout
= make_emacs_time (time_limit
, nsecs
);
4396 end_time
= add_emacs_time (current_emacs_time (), timeout
);
4401 int timeout_reduced_for_timers
= 0;
4403 /* If calling from keyboard input, do not quit
4404 since we want to return C-g as an input character.
4405 Otherwise, do pending quit if requested. */
4410 process_pending_signals ();
4413 /* Exit now if the cell we're waiting for became non-nil. */
4414 if (! NILP (wait_for_cell
) && ! NILP (XCAR (wait_for_cell
)))
4417 /* Compute time from now till when time limit is up */
4418 /* Exit if already run out */
4421 /* A negative timeout means
4422 gobble output available now
4423 but don't wait at all. */
4425 timeout
= make_emacs_time (0, 0);
4427 else if (time_limit
|| 0 < nsecs
)
4429 EMACS_TIME now
= current_emacs_time ();
4430 if (EMACS_TIME_LE (end_time
, now
))
4432 timeout
= sub_emacs_time (end_time
, now
);
4436 timeout
= make_emacs_time (100000, 0);
4439 /* Normally we run timers here.
4440 But not if wait_for_cell; in those cases,
4441 the wait is supposed to be short,
4442 and those callers cannot handle running arbitrary Lisp code here. */
4443 if (NILP (wait_for_cell
)
4444 && just_wait_proc
>= 0)
4446 EMACS_TIME timer_delay
;
4450 int old_timers_run
= timers_run
;
4451 struct buffer
*old_buffer
= current_buffer
;
4452 Lisp_Object old_window
= selected_window
;
4454 timer_delay
= timer_check ();
4456 /* If a timer has run, this might have changed buffers
4457 an alike. Make read_key_sequence aware of that. */
4458 if (timers_run
!= old_timers_run
4459 && (old_buffer
!= current_buffer
4460 || !EQ (old_window
, selected_window
))
4461 && waiting_for_user_input_p
== -1)
4462 record_asynch_buffer_change ();
4464 if (timers_run
!= old_timers_run
&& do_display
)
4465 /* We must retry, since a timer may have requeued itself
4466 and that could alter the time_delay. */
4467 redisplay_preserve_echo_area (9);
4471 while (!detect_input_pending ());
4473 /* If there is unread keyboard input, also return. */
4475 && requeued_events_pending_p ())
4478 /* A negative timeout means do not wait at all. */
4481 if (EMACS_TIME_VALID_P (timer_delay
))
4483 if (EMACS_TIME_LT (timer_delay
, timeout
))
4485 timeout
= timer_delay
;
4486 timeout_reduced_for_timers
= 1;
4491 /* This is so a breakpoint can be put here. */
4492 wait_reading_process_output_1 ();
4497 /* Cause C-g and alarm signals to take immediate action,
4498 and cause input available signals to zero out timeout.
4500 It is important that we do this before checking for process
4501 activity. If we get a SIGCHLD after the explicit checks for
4502 process activity, timeout is the only way we will know. */
4504 set_waiting_for_input (&timeout
);
4506 /* If status of something has changed, and no input is
4507 available, notify the user of the change right away. After
4508 this explicit check, we'll let the SIGCHLD handler zap
4509 timeout to get our attention. */
4510 if (update_tick
!= process_tick
)
4515 if (kbd_on_hold_p ())
4518 Atemp
= input_wait_mask
;
4521 timeout
= make_emacs_time (0, 0);
4522 if ((pselect (max (max_process_desc
, max_input_desc
) + 1,
4524 #ifdef NON_BLOCKING_CONNECT
4525 (num_pending_connects
> 0 ? &Ctemp
: NULL
),
4529 NULL
, &timeout
, NULL
)
4532 /* It's okay for us to do this and then continue with
4533 the loop, since timeout has already been zeroed out. */
4534 clear_waiting_for_input ();
4535 status_notify (NULL
);
4536 if (do_display
) redisplay_preserve_echo_area (13);
4540 /* Don't wait for output from a non-running process. Just
4541 read whatever data has already been received. */
4542 if (wait_proc
&& wait_proc
->raw_status_new
)
4543 update_status (wait_proc
);
4545 && ! EQ (wait_proc
->status
, Qrun
)
4546 && ! EQ (wait_proc
->status
, Qconnect
))
4548 int nread
, total_nread
= 0;
4550 clear_waiting_for_input ();
4551 XSETPROCESS (proc
, wait_proc
);
4553 /* Read data from the process, until we exhaust it. */
4554 while (wait_proc
->infd
>= 0)
4556 nread
= read_process_output (proc
, wait_proc
->infd
);
4563 total_nread
+= nread
;
4567 else if (nread
== -1 && EIO
== errno
)
4571 else if (nread
== -1 && EAGAIN
== errno
)
4575 else if (nread
== -1 && EWOULDBLOCK
== errno
)
4579 if (total_nread
> 0 && do_display
)
4580 redisplay_preserve_echo_area (10);
4585 /* Wait till there is something to do */
4587 if (wait_proc
&& just_wait_proc
)
4589 if (wait_proc
->infd
< 0) /* Terminated */
4591 FD_SET (wait_proc
->infd
, &Available
);
4595 else if (!NILP (wait_for_cell
))
4597 Available
= non_process_wait_mask
;
4604 Available
= non_keyboard_wait_mask
;
4606 Available
= input_wait_mask
;
4607 Writeok
= write_mask
;
4608 #ifdef SELECT_CANT_DO_WRITE_MASK
4613 check_delay
= wait_channel
>= 0 ? 0 : process_output_delay_count
;
4616 /* If frame size has changed or the window is newly mapped,
4617 redisplay now, before we start to wait. There is a race
4618 condition here; if a SIGIO arrives between now and the select
4619 and indicates that a frame is trashed, the select may block
4620 displaying a trashed screen. */
4621 if (frame_garbaged
&& do_display
)
4623 clear_waiting_for_input ();
4624 redisplay_preserve_echo_area (11);
4626 set_waiting_for_input (&timeout
);
4629 /* Skip the `select' call if input is available and we're
4630 waiting for keyboard input or a cell change (which can be
4631 triggered by processing X events). In the latter case, set
4632 nfds to 1 to avoid breaking the loop. */
4634 if ((read_kbd
|| !NILP (wait_for_cell
))
4635 && detect_input_pending ())
4637 nfds
= read_kbd
? 0 : 1;
4644 #ifdef ADAPTIVE_READ_BUFFERING
4645 /* Set the timeout for adaptive read buffering if any
4646 process has non-zero read_output_skip and non-zero
4647 read_output_delay, and we are not reading output for a
4648 specific wait_channel. It is not executed if
4649 Vprocess_adaptive_read_buffering is nil. */
4650 if (process_output_skip
&& check_delay
> 0)
4652 int nsecs
= EMACS_NSECS (timeout
);
4653 if (EMACS_SECS (timeout
) > 0 || nsecs
> READ_OUTPUT_DELAY_MAX
)
4654 nsecs
= READ_OUTPUT_DELAY_MAX
;
4655 for (channel
= 0; check_delay
> 0 && channel
<= max_process_desc
; channel
++)
4657 proc
= chan_process
[channel
];
4660 /* Find minimum non-zero read_output_delay among the
4661 processes with non-zero read_output_skip. */
4662 if (XPROCESS (proc
)->read_output_delay
> 0)
4665 if (!XPROCESS (proc
)->read_output_skip
)
4667 FD_CLR (channel
, &Available
);
4668 XPROCESS (proc
)->read_output_skip
= 0;
4669 if (XPROCESS (proc
)->read_output_delay
< nsecs
)
4670 nsecs
= XPROCESS (proc
)->read_output_delay
;
4673 timeout
= make_emacs_time (0, nsecs
);
4674 process_output_skip
= 0;
4677 #if defined (USE_GTK) || defined (HAVE_GCONF) || defined (HAVE_GSETTINGS)
4679 #elif defined (HAVE_NS)
4684 (max (max_process_desc
, max_input_desc
) + 1,
4686 (check_write
? &Writeok
: (SELECT_TYPE
*)0),
4687 NULL
, &timeout
, NULL
);
4690 /* GnuTLS buffers data internally. In lowat mode it leaves
4691 some data in the TCP buffers so that select works, but
4692 with custom pull/push functions we need to check if some
4693 data is available in the buffers manually. */
4698 /* We're not waiting on a specific process, so loop
4699 through all the channels and check for data.
4700 This is a workaround needed for some versions of
4701 the gnutls library -- 2.12.14 has been confirmed
4703 http://comments.gmane.org/gmane.emacs.devel/145074 */
4704 for (channel
= 0; channel
< MAXDESC
; ++channel
)
4705 if (! NILP (chan_process
[channel
]))
4707 struct Lisp_Process
*p
=
4708 XPROCESS (chan_process
[channel
]);
4709 if (p
&& p
->gnutls_p
&& p
->infd
4710 && ((emacs_gnutls_record_check_pending
4715 FD_SET (p
->infd
, &Available
);
4721 /* Check this specific channel. */
4722 if (wait_proc
->gnutls_p
/* Check for valid process. */
4723 /* Do we have pending data? */
4724 && ((emacs_gnutls_record_check_pending
4725 (wait_proc
->gnutls_state
))
4729 /* Set to Available. */
4730 FD_SET (wait_proc
->infd
, &Available
);
4739 /* Make C-g and alarm signals set flags again */
4740 clear_waiting_for_input ();
4742 /* If we woke up due to SIGWINCH, actually change size now. */
4743 do_pending_window_change (0);
4745 if ((time_limit
|| nsecs
) && nfds
== 0 && ! timeout_reduced_for_timers
)
4746 /* We waited the full specified time, so return now. */
4750 if (xerrno
== EINTR
)
4752 else if (xerrno
== EBADF
)
4755 /* AIX doesn't handle PTY closure the same way BSD does. On AIX,
4756 the child's closure of the pts gives the parent a SIGHUP, and
4757 the ptc file descriptor is automatically closed,
4758 yielding EBADF here or at select() call above.
4759 So, SIGHUP is ignored (see def of PTY_TTY_NAME_SPRINTF
4760 in m/ibmrt-aix.h), and here we just ignore the select error.
4761 Cleanup occurs c/o status_notify after SIGCLD. */
4762 no_avail
= 1; /* Cannot depend on values returned */
4768 error ("select error: %s", emacs_strerror (xerrno
));
4773 FD_ZERO (&Available
);
4777 #if 0 /* When polling is used, interrupt_input is 0,
4778 so get_input_pending should read the input.
4779 So this should not be needed. */
4780 /* If we are using polling for input,
4781 and we see input available, make it get read now.
4782 Otherwise it might not actually get read for a second.
4783 And on hpux, since we turn off polling in wait_reading_process_output,
4784 it might never get read at all if we don't spend much time
4785 outside of wait_reading_process_output. */
4786 if (read_kbd
&& interrupt_input
4787 && keyboard_bit_set (&Available
)
4788 && input_polling_used ())
4789 kill (getpid (), SIGALRM
);
4792 /* Check for keyboard input */
4793 /* If there is any, return immediately
4794 to give it higher priority than subprocesses */
4798 int old_timers_run
= timers_run
;
4799 struct buffer
*old_buffer
= current_buffer
;
4800 Lisp_Object old_window
= selected_window
;
4803 if (detect_input_pending_run_timers (do_display
))
4805 swallow_events (do_display
);
4806 if (detect_input_pending_run_timers (do_display
))
4810 /* If a timer has run, this might have changed buffers
4811 an alike. Make read_key_sequence aware of that. */
4812 if (timers_run
!= old_timers_run
4813 && waiting_for_user_input_p
== -1
4814 && (old_buffer
!= current_buffer
4815 || !EQ (old_window
, selected_window
)))
4816 record_asynch_buffer_change ();
4822 /* If there is unread keyboard input, also return. */
4824 && requeued_events_pending_p ())
4827 /* If we are not checking for keyboard input now,
4828 do process events (but don't run any timers).
4829 This is so that X events will be processed.
4830 Otherwise they may have to wait until polling takes place.
4831 That would causes delays in pasting selections, for example.
4833 (We used to do this only if wait_for_cell.) */
4834 if (read_kbd
== 0 && detect_input_pending ())
4836 swallow_events (do_display
);
4837 #if 0 /* Exiting when read_kbd doesn't request that seems wrong, though. */
4838 if (detect_input_pending ())
4843 /* Exit now if the cell we're waiting for became non-nil. */
4844 if (! NILP (wait_for_cell
) && ! NILP (XCAR (wait_for_cell
)))
4848 /* If we think we have keyboard input waiting, but didn't get SIGIO,
4849 go read it. This can happen with X on BSD after logging out.
4850 In that case, there really is no input and no SIGIO,
4851 but select says there is input. */
4853 if (read_kbd
&& interrupt_input
4854 && keyboard_bit_set (&Available
) && ! noninteractive
)
4855 kill (getpid (), SIGIO
);
4859 got_some_input
|= nfds
> 0;
4861 /* If checking input just got us a size-change event from X,
4862 obey it now if we should. */
4863 if (read_kbd
|| ! NILP (wait_for_cell
))
4864 do_pending_window_change (0);
4866 /* Check for data from a process. */
4867 if (no_avail
|| nfds
== 0)
4870 for (channel
= 0; channel
<= max_input_desc
; ++channel
)
4872 struct fd_callback_data
*d
= &fd_callback_info
[channel
];
4874 && ((d
->condition
& FOR_READ
4875 && FD_ISSET (channel
, &Available
))
4876 || (d
->condition
& FOR_WRITE
4877 && FD_ISSET (channel
, &write_mask
))))
4878 d
->func (channel
, d
->data
);
4881 for (channel
= 0; channel
<= max_process_desc
; channel
++)
4883 if (FD_ISSET (channel
, &Available
)
4884 && FD_ISSET (channel
, &non_keyboard_wait_mask
)
4885 && !FD_ISSET (channel
, &non_process_wait_mask
))
4889 /* If waiting for this channel, arrange to return as
4890 soon as no more input to be processed. No more
4892 if (wait_channel
== channel
)
4898 proc
= chan_process
[channel
];
4902 /* If this is a server stream socket, accept connection. */
4903 if (EQ (XPROCESS (proc
)->status
, Qlisten
))
4905 server_accept_connection (proc
, channel
);
4909 /* Read data from the process, starting with our
4910 buffered-ahead character if we have one. */
4912 nread
= read_process_output (proc
, channel
);
4915 /* Since read_process_output can run a filter,
4916 which can call accept-process-output,
4917 don't try to read from any other processes
4918 before doing the select again. */
4919 FD_ZERO (&Available
);
4922 redisplay_preserve_echo_area (12);
4925 else if (nread
== -1 && errno
== EWOULDBLOCK
)
4928 /* ISC 4.1 defines both EWOULDBLOCK and O_NONBLOCK,
4929 and Emacs uses O_NONBLOCK, so what we get is EAGAIN. */
4931 else if (nread
== -1 && errno
== EAGAIN
)
4935 else if (nread
== -1 && errno
== EAGAIN
)
4937 /* Note that we cannot distinguish between no input
4938 available now and a closed pipe.
4939 With luck, a closed pipe will be accompanied by
4940 subprocess termination and SIGCHLD. */
4941 else if (nread
== 0 && !NETCONN_P (proc
) && !SERIALCONN_P (proc
))
4943 #endif /* O_NDELAY */
4944 #endif /* O_NONBLOCK */
4946 /* On some OSs with ptys, when the process on one end of
4947 a pty exits, the other end gets an error reading with
4948 errno = EIO instead of getting an EOF (0 bytes read).
4949 Therefore, if we get an error reading and errno =
4950 EIO, just continue, because the child process has
4951 exited and should clean itself up soon (e.g. when we
4954 However, it has been known to happen that the SIGCHLD
4955 got lost. So raise the signal again just in case.
4957 else if (nread
== -1 && errno
== EIO
)
4959 struct Lisp_Process
*p
= XPROCESS (proc
);
4961 /* Clear the descriptor now, so we only raise the
4963 FD_CLR (channel
, &input_wait_mask
);
4964 FD_CLR (channel
, &non_keyboard_wait_mask
);
4968 /* If the EIO occurs on a pty, the SIGCHLD handler's
4969 waitpid call will not find the process object to
4970 delete. Do it here. */
4971 p
->tick
= ++process_tick
;
4972 pset_status (p
, Qfailed
);
4975 kill (getpid (), SIGCHLD
);
4977 #endif /* HAVE_PTYS */
4978 /* If we can detect process termination, don't consider the
4979 process gone just because its pipe is closed. */
4981 else if (nread
== 0 && !NETCONN_P (proc
) && !SERIALCONN_P (proc
))
4986 /* Preserve status of processes already terminated. */
4987 XPROCESS (proc
)->tick
= ++process_tick
;
4988 deactivate_process (proc
);
4989 if (XPROCESS (proc
)->raw_status_new
)
4990 update_status (XPROCESS (proc
));
4991 if (EQ (XPROCESS (proc
)->status
, Qrun
))
4992 pset_status (XPROCESS (proc
),
4993 list2 (Qexit
, make_number (256)));
4996 #ifdef NON_BLOCKING_CONNECT
4997 if (FD_ISSET (channel
, &Writeok
)
4998 && FD_ISSET (channel
, &connect_wait_mask
))
5000 struct Lisp_Process
*p
;
5002 FD_CLR (channel
, &connect_wait_mask
);
5003 FD_CLR (channel
, &write_mask
);
5004 if (--num_pending_connects
< 0)
5007 proc
= chan_process
[channel
];
5011 p
= XPROCESS (proc
);
5014 /* getsockopt(,,SO_ERROR,,) is said to hang on some systems.
5015 So only use it on systems where it is known to work. */
5017 socklen_t xlen
= sizeof (xerrno
);
5018 if (getsockopt (channel
, SOL_SOCKET
, SO_ERROR
, &xerrno
, &xlen
))
5023 struct sockaddr pname
;
5024 int pnamelen
= sizeof (pname
);
5026 /* If connection failed, getpeername will fail. */
5028 if (getpeername (channel
, &pname
, &pnamelen
) < 0)
5030 /* Obtain connect failure code through error slippage. */
5033 if (errno
== ENOTCONN
&& read (channel
, &dummy
, 1) < 0)
5040 p
->tick
= ++process_tick
;
5041 pset_status (p
, list2 (Qfailed
, make_number (xerrno
)));
5042 deactivate_process (proc
);
5046 pset_status (p
, Qrun
);
5047 /* Execute the sentinel here. If we had relied on
5048 status_notify to do it later, it will read input
5049 from the process before calling the sentinel. */
5050 exec_sentinel (proc
, build_string ("open\n"));
5051 if (!EQ (p
->filter
, Qt
) && !EQ (p
->command
, Qt
))
5053 FD_SET (p
->infd
, &input_wait_mask
);
5054 FD_SET (p
->infd
, &non_keyboard_wait_mask
);
5058 #endif /* NON_BLOCKING_CONNECT */
5059 } /* end for each file descriptor */
5060 } /* end while exit conditions not met */
5062 unbind_to (count
, Qnil
);
5064 /* If calling from keyboard input, do not quit
5065 since we want to return C-g as an input character.
5066 Otherwise, do pending quit if requested. */
5069 /* Prevent input_pending from remaining set if we quit. */
5070 clear_input_pending ();
5074 return got_some_input
;
5077 /* Given a list (FUNCTION ARGS...), apply FUNCTION to the ARGS. */
5080 read_process_output_call (Lisp_Object fun_and_args
)
5082 return apply1 (XCAR (fun_and_args
), XCDR (fun_and_args
));
5086 read_process_output_error_handler (Lisp_Object error_val
)
5088 cmd_error_internal (error_val
, "error in process filter: ");
5090 update_echo_area ();
5091 Fsleep_for (make_number (2), Qnil
);
5095 /* Read pending output from the process channel,
5096 starting with our buffered-ahead character if we have one.
5097 Yield number of decoded characters read.
5099 This function reads at most 4096 characters.
5100 If you want to read all available subprocess output,
5101 you must call it repeatedly until it returns zero.
5103 The characters read are decoded according to PROC's coding-system
5107 read_process_output (Lisp_Object proc
, register int channel
)
5109 register ssize_t nbytes
;
5111 register Lisp_Object outstream
;
5112 register struct Lisp_Process
*p
= XPROCESS (proc
);
5113 register ptrdiff_t opoint
;
5114 struct coding_system
*coding
= proc_decode_coding_system
[channel
];
5115 int carryover
= p
->decoding_carryover
;
5117 ptrdiff_t count
= SPECPDL_INDEX ();
5118 Lisp_Object odeactivate
;
5120 chars
= alloca (carryover
+ readmax
);
5122 /* See the comment above. */
5123 memcpy (chars
, SDATA (p
->decoding_buf
), carryover
);
5125 #ifdef DATAGRAM_SOCKETS
5126 /* We have a working select, so proc_buffered_char is always -1. */
5127 if (DATAGRAM_CHAN_P (channel
))
5129 socklen_t len
= datagram_address
[channel
].len
;
5130 nbytes
= recvfrom (channel
, chars
+ carryover
, readmax
,
5131 0, datagram_address
[channel
].sa
, &len
);
5136 int buffered
= 0 <= proc_buffered_char
[channel
];
5139 chars
[carryover
] = proc_buffered_char
[channel
];
5140 proc_buffered_char
[channel
] = -1;
5144 nbytes
= emacs_gnutls_read (p
, chars
+ carryover
+ buffered
,
5145 readmax
- buffered
);
5148 nbytes
= emacs_read (channel
, chars
+ carryover
+ buffered
,
5149 readmax
- buffered
);
5150 #ifdef ADAPTIVE_READ_BUFFERING
5151 if (nbytes
> 0 && p
->adaptive_read_buffering
)
5153 int delay
= p
->read_output_delay
;
5156 if (delay
< READ_OUTPUT_DELAY_MAX_MAX
)
5159 process_output_delay_count
++;
5160 delay
+= READ_OUTPUT_DELAY_INCREMENT
* 2;
5163 else if (delay
> 0 && nbytes
== readmax
- buffered
)
5165 delay
-= READ_OUTPUT_DELAY_INCREMENT
;
5167 process_output_delay_count
--;
5169 p
->read_output_delay
= delay
;
5172 p
->read_output_skip
= 1;
5173 process_output_skip
= 1;
5178 nbytes
+= buffered
&& nbytes
<= 0;
5181 p
->decoding_carryover
= 0;
5183 /* At this point, NBYTES holds number of bytes just received
5184 (including the one in proc_buffered_char[channel]). */
5187 if (nbytes
< 0 || coding
->mode
& CODING_MODE_LAST_BLOCK
)
5189 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
5192 /* Now set NBYTES how many bytes we must decode. */
5193 nbytes
+= carryover
;
5195 odeactivate
= Vdeactivate_mark
;
5196 /* There's no good reason to let process filters change the current
5197 buffer, and many callers of accept-process-output, sit-for, and
5198 friends don't expect current-buffer to be changed from under them. */
5199 record_unwind_current_buffer ();
5201 /* Read and dispose of the process output. */
5202 outstream
= p
->filter
;
5203 if (!NILP (outstream
))
5206 bool outer_running_asynch_code
= running_asynch_code
;
5207 int waiting
= waiting_for_user_input_p
;
5209 /* No need to gcpro these, because all we do with them later
5210 is test them for EQness, and none of them should be a string. */
5212 Lisp_Object obuffer
, okeymap
;
5213 XSETBUFFER (obuffer
, current_buffer
);
5214 okeymap
= BVAR (current_buffer
, keymap
);
5217 /* We inhibit quit here instead of just catching it so that
5218 hitting ^G when a filter happens to be running won't screw
5220 specbind (Qinhibit_quit
, Qt
);
5221 specbind (Qlast_nonmenu_event
, Qt
);
5223 /* In case we get recursively called,
5224 and we already saved the match data nonrecursively,
5225 save the same match data in safely recursive fashion. */
5226 if (outer_running_asynch_code
)
5229 /* Don't clobber the CURRENT match data, either! */
5230 tem
= Fmatch_data (Qnil
, Qnil
, Qnil
);
5231 restore_search_regs ();
5232 record_unwind_save_match_data ();
5233 Fset_match_data (tem
, Qt
);
5236 /* For speed, if a search happens within this code,
5237 save the match data in a special nonrecursive fashion. */
5238 running_asynch_code
= 1;
5240 decode_coding_c_string (coding
, (unsigned char *) chars
, nbytes
, Qt
);
5241 text
= coding
->dst_object
;
5242 Vlast_coding_system_used
= CODING_ID_NAME (coding
->id
);
5243 /* A new coding system might be found. */
5244 if (!EQ (p
->decode_coding_system
, Vlast_coding_system_used
))
5246 pset_decode_coding_system (p
, Vlast_coding_system_used
);
5248 /* Don't call setup_coding_system for
5249 proc_decode_coding_system[channel] here. It is done in
5250 detect_coding called via decode_coding above. */
5252 /* If a coding system for encoding is not yet decided, we set
5253 it as the same as coding-system for decoding.
5255 But, before doing that we must check if
5256 proc_encode_coding_system[p->outfd] surely points to a
5257 valid memory because p->outfd will be changed once EOF is
5258 sent to the process. */
5259 if (NILP (p
->encode_coding_system
)
5260 && proc_encode_coding_system
[p
->outfd
])
5262 pset_encode_coding_system
5263 (p
, coding_inherit_eol_type (Vlast_coding_system_used
, Qnil
));
5264 setup_coding_system (p
->encode_coding_system
,
5265 proc_encode_coding_system
[p
->outfd
]);
5269 if (coding
->carryover_bytes
> 0)
5271 if (SCHARS (p
->decoding_buf
) < coding
->carryover_bytes
)
5272 pset_decoding_buf (p
, make_uninit_string (coding
->carryover_bytes
));
5273 memcpy (SDATA (p
->decoding_buf
), coding
->carryover
,
5274 coding
->carryover_bytes
);
5275 p
->decoding_carryover
= coding
->carryover_bytes
;
5277 if (SBYTES (text
) > 0)
5278 /* FIXME: It's wrong to wrap or not based on debug-on-error, and
5279 sometimes it's simply wrong to wrap (e.g. when called from
5280 accept-process-output). */
5281 internal_condition_case_1 (read_process_output_call
,
5283 Fcons (proc
, Fcons (text
, Qnil
))),
5284 !NILP (Vdebug_on_error
) ? Qnil
: Qerror
,
5285 read_process_output_error_handler
);
5287 /* If we saved the match data nonrecursively, restore it now. */
5288 restore_search_regs ();
5289 running_asynch_code
= outer_running_asynch_code
;
5291 /* Restore waiting_for_user_input_p as it was
5292 when we were called, in case the filter clobbered it. */
5293 waiting_for_user_input_p
= waiting
;
5295 #if 0 /* Call record_asynch_buffer_change unconditionally,
5296 because we might have changed minor modes or other things
5297 that affect key bindings. */
5298 if (! EQ (Fcurrent_buffer (), obuffer
)
5299 || ! EQ (current_buffer
->keymap
, okeymap
))
5301 /* But do it only if the caller is actually going to read events.
5302 Otherwise there's no need to make him wake up, and it could
5303 cause trouble (for example it would make sit_for return). */
5304 if (waiting_for_user_input_p
== -1)
5305 record_asynch_buffer_change ();
5308 /* If no filter, write into buffer if it isn't dead. */
5309 else if (!NILP (p
->buffer
) && !NILP (BVAR (XBUFFER (p
->buffer
), name
)))
5311 Lisp_Object old_read_only
;
5312 ptrdiff_t old_begv
, old_zv
;
5313 ptrdiff_t old_begv_byte
, old_zv_byte
;
5314 ptrdiff_t before
, before_byte
;
5315 ptrdiff_t opoint_byte
;
5319 Fset_buffer (p
->buffer
);
5321 opoint_byte
= PT_BYTE
;
5322 old_read_only
= BVAR (current_buffer
, read_only
);
5325 old_begv_byte
= BEGV_BYTE
;
5326 old_zv_byte
= ZV_BYTE
;
5328 bset_read_only (current_buffer
, Qnil
);
5330 /* Insert new output into buffer
5331 at the current end-of-output marker,
5332 thus preserving logical ordering of input and output. */
5333 if (XMARKER (p
->mark
)->buffer
)
5334 SET_PT_BOTH (clip_to_bounds (BEGV
,
5335 marker_position (p
->mark
), ZV
),
5336 clip_to_bounds (BEGV_BYTE
,
5337 marker_byte_position (p
->mark
),
5340 SET_PT_BOTH (ZV
, ZV_BYTE
);
5342 before_byte
= PT_BYTE
;
5344 /* If the output marker is outside of the visible region, save
5345 the restriction and widen. */
5346 if (! (BEGV
<= PT
&& PT
<= ZV
))
5349 decode_coding_c_string (coding
, (unsigned char *) chars
, nbytes
, Qt
);
5350 text
= coding
->dst_object
;
5351 Vlast_coding_system_used
= CODING_ID_NAME (coding
->id
);
5352 /* A new coding system might be found. See the comment in the
5353 similar code in the previous `if' block. */
5354 if (!EQ (p
->decode_coding_system
, Vlast_coding_system_used
))
5356 pset_decode_coding_system (p
, Vlast_coding_system_used
);
5357 if (NILP (p
->encode_coding_system
)
5358 && proc_encode_coding_system
[p
->outfd
])
5360 pset_encode_coding_system
5361 (p
, coding_inherit_eol_type (Vlast_coding_system_used
, Qnil
));
5362 setup_coding_system (p
->encode_coding_system
,
5363 proc_encode_coding_system
[p
->outfd
]);
5366 if (coding
->carryover_bytes
> 0)
5368 if (SCHARS (p
->decoding_buf
) < coding
->carryover_bytes
)
5369 pset_decoding_buf (p
, make_uninit_string (coding
->carryover_bytes
));
5370 memcpy (SDATA (p
->decoding_buf
), coding
->carryover
,
5371 coding
->carryover_bytes
);
5372 p
->decoding_carryover
= coding
->carryover_bytes
;
5374 /* Adjust the multibyteness of TEXT to that of the buffer. */
5375 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
))
5376 != ! STRING_MULTIBYTE (text
))
5377 text
= (STRING_MULTIBYTE (text
)
5378 ? Fstring_as_unibyte (text
)
5379 : Fstring_to_multibyte (text
));
5380 /* Insert before markers in case we are inserting where
5381 the buffer's mark is, and the user's next command is Meta-y. */
5382 insert_from_string_before_markers (text
, 0, 0,
5383 SCHARS (text
), SBYTES (text
), 0);
5385 /* Make sure the process marker's position is valid when the
5386 process buffer is changed in the signal_after_change above.
5387 W3 is known to do that. */
5388 if (BUFFERP (p
->buffer
)
5389 && (b
= XBUFFER (p
->buffer
), b
!= current_buffer
))
5390 set_marker_both (p
->mark
, p
->buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
5392 set_marker_both (p
->mark
, p
->buffer
, PT
, PT_BYTE
);
5394 update_mode_lines
++;
5396 /* Make sure opoint and the old restrictions
5397 float ahead of any new text just as point would. */
5398 if (opoint
>= before
)
5400 opoint
+= PT
- before
;
5401 opoint_byte
+= PT_BYTE
- before_byte
;
5403 if (old_begv
> before
)
5405 old_begv
+= PT
- before
;
5406 old_begv_byte
+= PT_BYTE
- before_byte
;
5408 if (old_zv
>= before
)
5410 old_zv
+= PT
- before
;
5411 old_zv_byte
+= PT_BYTE
- before_byte
;
5414 /* If the restriction isn't what it should be, set it. */
5415 if (old_begv
!= BEGV
|| old_zv
!= ZV
)
5416 Fnarrow_to_region (make_number (old_begv
), make_number (old_zv
));
5419 bset_read_only (current_buffer
, old_read_only
);
5420 SET_PT_BOTH (opoint
, opoint_byte
);
5422 /* Handling the process output should not deactivate the mark. */
5423 Vdeactivate_mark
= odeactivate
;
5425 unbind_to (count
, Qnil
);
5429 /* Sending data to subprocess */
5431 static jmp_buf send_process_frame
;
5432 static Lisp_Object process_sent_to
;
5434 static _Noreturn
void
5435 handle_pipe_signal (int sig
)
5437 sigunblock (sigmask (SIGPIPE
));
5438 _longjmp (send_process_frame
, 1);
5442 deliver_pipe_signal (int sig
)
5444 handle_on_main_thread (sig
, handle_pipe_signal
);
5447 /* In send_process, when a write fails temporarily,
5448 wait_reading_process_output is called. It may execute user code,
5449 e.g. timers, that attempts to write new data to the same process.
5450 We must ensure that data is sent in the right order, and not
5451 interspersed half-completed with other writes (Bug#10815). This is
5452 handled by the write_queue element of struct process. It is a list
5453 with each entry having the form
5455 (string . (offset . length))
5457 where STRING is a lisp string, OFFSET is the offset into the
5458 string's byte sequence from which we should begin to send, and
5459 LENGTH is the number of bytes left to send. */
5461 /* Create a new entry in write_queue.
5462 INPUT_OBJ should be a buffer, string Qt, or Qnil.
5463 BUF is a pointer to the string sequence of the input_obj or a C
5464 string in case of Qt or Qnil. */
5467 write_queue_push (struct Lisp_Process
*p
, Lisp_Object input_obj
,
5468 const char *buf
, ptrdiff_t len
, int front
)
5471 Lisp_Object entry
, obj
;
5473 if (STRINGP (input_obj
))
5475 offset
= buf
- SSDATA (input_obj
);
5481 obj
= make_unibyte_string (buf
, len
);
5484 entry
= Fcons (obj
, Fcons (make_number (offset
), make_number (len
)));
5487 pset_write_queue (p
, Fcons (entry
, p
->write_queue
));
5489 pset_write_queue (p
, nconc2 (p
->write_queue
, Fcons (entry
, Qnil
)));
5492 /* Remove the first element in the write_queue of process P, put its
5493 contents in OBJ, BUF and LEN, and return non-zero. If the
5494 write_queue is empty, return zero. */
5497 write_queue_pop (struct Lisp_Process
*p
, Lisp_Object
*obj
,
5498 const char **buf
, ptrdiff_t *len
)
5500 Lisp_Object entry
, offset_length
;
5503 if (NILP (p
->write_queue
))
5506 entry
= XCAR (p
->write_queue
);
5507 pset_write_queue (p
, XCDR (p
->write_queue
));
5509 *obj
= XCAR (entry
);
5510 offset_length
= XCDR (entry
);
5512 *len
= XINT (XCDR (offset_length
));
5513 offset
= XINT (XCAR (offset_length
));
5514 *buf
= SSDATA (*obj
) + offset
;
5519 /* Send some data to process PROC.
5520 BUF is the beginning of the data; LEN is the number of characters.
5521 OBJECT is the Lisp object that the data comes from. If OBJECT is
5522 nil or t, it means that the data comes from C string.
5524 If OBJECT is not nil, the data is encoded by PROC's coding-system
5525 for encoding before it is sent.
5527 This function can evaluate Lisp code and can garbage collect. */
5530 send_process (volatile Lisp_Object proc
, const char *volatile buf
,
5531 volatile ptrdiff_t len
, volatile Lisp_Object object
)
5533 /* Use volatile to protect variables from being clobbered by longjmp. */
5534 struct Lisp_Process
*p
= XPROCESS (proc
);
5536 struct coding_system
*coding
;
5537 void (*volatile old_sigpipe
) (int);
5539 if (p
->raw_status_new
)
5541 if (! EQ (p
->status
, Qrun
))
5542 error ("Process %s not running", SDATA (p
->name
));
5544 error ("Output file descriptor of %s is closed", SDATA (p
->name
));
5546 coding
= proc_encode_coding_system
[p
->outfd
];
5547 Vlast_coding_system_used
= CODING_ID_NAME (coding
->id
);
5549 if ((STRINGP (object
) && STRING_MULTIBYTE (object
))
5550 || (BUFFERP (object
)
5551 && !NILP (BVAR (XBUFFER (object
), enable_multibyte_characters
)))
5554 pset_encode_coding_system
5555 (p
, complement_process_encoding_system (p
->encode_coding_system
));
5556 if (!EQ (Vlast_coding_system_used
, p
->encode_coding_system
))
5558 /* The coding system for encoding was changed to raw-text
5559 because we sent a unibyte text previously. Now we are
5560 sending a multibyte text, thus we must encode it by the
5561 original coding system specified for the current process.
5563 Another reason we come here is that the coding system
5564 was just complemented and a new one was returned by
5565 complement_process_encoding_system. */
5566 setup_coding_system (p
->encode_coding_system
, coding
);
5567 Vlast_coding_system_used
= p
->encode_coding_system
;
5569 coding
->src_multibyte
= 1;
5573 coding
->src_multibyte
= 0;
5574 /* For sending a unibyte text, character code conversion should
5575 not take place but EOL conversion should. So, setup raw-text
5576 or one of the subsidiary if we have not yet done it. */
5577 if (CODING_REQUIRE_ENCODING (coding
))
5579 if (CODING_REQUIRE_FLUSHING (coding
))
5581 /* But, before changing the coding, we must flush out data. */
5582 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
5583 send_process (proc
, "", 0, Qt
);
5584 coding
->mode
&= CODING_MODE_LAST_BLOCK
;
5586 setup_coding_system (raw_text_coding_system
5587 (Vlast_coding_system_used
),
5589 coding
->src_multibyte
= 0;
5592 coding
->dst_multibyte
= 0;
5594 if (CODING_REQUIRE_ENCODING (coding
))
5596 coding
->dst_object
= Qt
;
5597 if (BUFFERP (object
))
5599 ptrdiff_t from_byte
, from
, to
;
5600 ptrdiff_t save_pt
, save_pt_byte
;
5601 struct buffer
*cur
= current_buffer
;
5603 set_buffer_internal (XBUFFER (object
));
5604 save_pt
= PT
, save_pt_byte
= PT_BYTE
;
5606 from_byte
= PTR_BYTE_POS ((unsigned char *) buf
);
5607 from
= BYTE_TO_CHAR (from_byte
);
5608 to
= BYTE_TO_CHAR (from_byte
+ len
);
5609 TEMP_SET_PT_BOTH (from
, from_byte
);
5610 encode_coding_object (coding
, object
, from
, from_byte
,
5611 to
, from_byte
+ len
, Qt
);
5612 TEMP_SET_PT_BOTH (save_pt
, save_pt_byte
);
5613 set_buffer_internal (cur
);
5615 else if (STRINGP (object
))
5617 encode_coding_object (coding
, object
, 0, 0, SCHARS (object
),
5618 SBYTES (object
), Qt
);
5622 coding
->dst_object
= make_unibyte_string (buf
, len
);
5623 coding
->produced
= len
;
5626 len
= coding
->produced
;
5627 object
= coding
->dst_object
;
5628 buf
= SSDATA (object
);
5631 if (pty_max_bytes
== 0)
5633 #if defined (HAVE_FPATHCONF) && defined (_PC_MAX_CANON)
5634 pty_max_bytes
= fpathconf (p
->outfd
, _PC_MAX_CANON
);
5635 if (pty_max_bytes
< 0)
5636 pty_max_bytes
= 250;
5638 pty_max_bytes
= 250;
5640 /* Deduct one, to leave space for the eof. */
5644 /* 2000-09-21: Emacs 20.7, sparc-sun-solaris-2.6, GCC 2.95.2,
5645 CFLAGS="-g -O": The value of the parameter `proc' is clobbered
5646 when returning with longjmp despite being declared volatile. */
5647 if (!_setjmp (send_process_frame
))
5649 p
= XPROCESS (proc
); /* Repair any setjmp clobbering. */
5650 process_sent_to
= proc
;
5652 /* If there is already data in the write_queue, put the new data
5653 in the back of queue. Otherwise, ignore it. */
5654 if (!NILP (p
->write_queue
))
5655 write_queue_push (p
, object
, buf
, len
, 0);
5657 do /* while !NILP (p->write_queue) */
5659 ptrdiff_t cur_len
= -1;
5660 const char *cur_buf
;
5661 Lisp_Object cur_object
;
5663 /* If write_queue is empty, ignore it. */
5664 if (!write_queue_pop (p
, &cur_object
, &cur_buf
, &cur_len
))
5668 cur_object
= object
;
5673 /* Send this batch, using one or more write calls. */
5674 ptrdiff_t written
= 0;
5675 int outfd
= p
->outfd
;
5676 old_sigpipe
= signal (SIGPIPE
, deliver_pipe_signal
);
5677 #ifdef DATAGRAM_SOCKETS
5678 if (DATAGRAM_CHAN_P (outfd
))
5680 rv
= sendto (outfd
, cur_buf
, cur_len
,
5681 0, datagram_address
[outfd
].sa
,
5682 datagram_address
[outfd
].len
);
5685 else if (errno
== EMSGSIZE
)
5687 signal (SIGPIPE
, old_sigpipe
);
5688 report_file_error ("sending datagram",
5689 Fcons (proc
, Qnil
));
5697 written
= emacs_gnutls_write (p
, cur_buf
, cur_len
);
5700 written
= emacs_write (outfd
, cur_buf
, cur_len
);
5701 rv
= (written
? 0 : -1);
5702 #ifdef ADAPTIVE_READ_BUFFERING
5703 if (p
->read_output_delay
> 0
5704 && p
->adaptive_read_buffering
== 1)
5706 p
->read_output_delay
= 0;
5707 process_output_delay_count
--;
5708 p
->read_output_skip
= 0;
5712 signal (SIGPIPE
, old_sigpipe
);
5718 || errno
== EWOULDBLOCK
5724 /* Buffer is full. Wait, accepting input;
5725 that may allow the program
5726 to finish doing output and read more. */
5728 #ifdef BROKEN_PTY_READ_AFTER_EAGAIN
5729 /* A gross hack to work around a bug in FreeBSD.
5730 In the following sequence, read(2) returns
5734 write(2) 954 bytes, get EAGAIN
5735 read(2) 1024 bytes in process_read_output
5736 read(2) 11 bytes in process_read_output
5738 That is, read(2) returns more bytes than have
5739 ever been written successfully. The 1033 bytes
5740 read are the 1022 bytes written successfully
5741 after processing (for example with CRs added if
5742 the terminal is set up that way which it is
5743 here). The same bytes will be seen again in a
5744 later read(2), without the CRs. */
5746 if (errno
== EAGAIN
)
5749 ioctl (p
->outfd
, TIOCFLUSH
, &flags
);
5751 #endif /* BROKEN_PTY_READ_AFTER_EAGAIN */
5753 /* Put what we should have written in wait_queue. */
5754 write_queue_push (p
, cur_object
, cur_buf
, cur_len
, 1);
5755 wait_reading_process_output (0, 20 * 1000 * 1000,
5756 0, 0, Qnil
, NULL
, 0);
5757 /* Reread queue, to see what is left. */
5761 /* This is a real error. */
5762 report_file_error ("writing to process", Fcons (proc
, Qnil
));
5768 while (!NILP (p
->write_queue
));
5772 signal (SIGPIPE
, old_sigpipe
);
5773 proc
= process_sent_to
;
5774 p
= XPROCESS (proc
);
5775 p
->raw_status_new
= 0;
5776 pset_status (p
, Fcons (Qexit
, Fcons (make_number (256), Qnil
)));
5777 p
->tick
= ++process_tick
;
5778 deactivate_process (proc
);
5779 error ("SIGPIPE raised on process %s; closed it", SDATA (p
->name
));
5783 DEFUN ("process-send-region", Fprocess_send_region
, Sprocess_send_region
,
5785 doc
: /* Send current contents of region as input to PROCESS.
5786 PROCESS may be a process, a buffer, the name of a process or buffer, or
5787 nil, indicating the current buffer's process.
5788 Called from program, takes three arguments, PROCESS, START and END.
5789 If the region is more than 500 characters long,
5790 it is sent in several bunches. This may happen even for shorter regions.
5791 Output from processes can arrive in between bunches. */)
5792 (Lisp_Object process
, Lisp_Object start
, Lisp_Object end
)
5795 ptrdiff_t start1
, end1
;
5797 proc
= get_process (process
);
5798 validate_region (&start
, &end
);
5800 if (XINT (start
) < GPT
&& XINT (end
) > GPT
)
5801 move_gap (XINT (start
));
5803 start1
= CHAR_TO_BYTE (XINT (start
));
5804 end1
= CHAR_TO_BYTE (XINT (end
));
5805 send_process (proc
, (char *) BYTE_POS_ADDR (start1
), end1
- start1
,
5806 Fcurrent_buffer ());
5811 DEFUN ("process-send-string", Fprocess_send_string
, Sprocess_send_string
,
5813 doc
: /* Send PROCESS the contents of STRING as input.
5814 PROCESS may be a process, a buffer, the name of a process or buffer, or
5815 nil, indicating the current buffer's process.
5816 If STRING is more than 500 characters long,
5817 it is sent in several bunches. This may happen even for shorter strings.
5818 Output from processes can arrive in between bunches. */)
5819 (Lisp_Object process
, Lisp_Object string
)
5822 CHECK_STRING (string
);
5823 proc
= get_process (process
);
5824 send_process (proc
, SSDATA (string
),
5825 SBYTES (string
), string
);
5829 /* Return the foreground process group for the tty/pty that
5830 the process P uses. */
5832 emacs_get_tty_pgrp (struct Lisp_Process
*p
)
5837 if (ioctl (p
->infd
, TIOCGPGRP
, &gid
) == -1 && ! NILP (p
->tty_name
))
5840 /* Some OS:es (Solaris 8/9) does not allow TIOCGPGRP from the
5841 master side. Try the slave side. */
5842 fd
= emacs_open (SSDATA (p
->tty_name
), O_RDONLY
, 0);
5846 ioctl (fd
, TIOCGPGRP
, &gid
);
5850 #endif /* defined (TIOCGPGRP ) */
5855 DEFUN ("process-running-child-p", Fprocess_running_child_p
,
5856 Sprocess_running_child_p
, 0, 1, 0,
5857 doc
: /* Return t if PROCESS has given the terminal to a child.
5858 If the operating system does not make it possible to find out,
5859 return t unconditionally. */)
5860 (Lisp_Object process
)
5862 /* Initialize in case ioctl doesn't exist or gives an error,
5863 in a way that will cause returning t. */
5866 struct Lisp_Process
*p
;
5868 proc
= get_process (process
);
5869 p
= XPROCESS (proc
);
5871 if (!EQ (p
->type
, Qreal
))
5872 error ("Process %s is not a subprocess",
5875 error ("Process %s is not active",
5878 gid
= emacs_get_tty_pgrp (p
);
5885 /* send a signal number SIGNO to PROCESS.
5886 If CURRENT_GROUP is t, that means send to the process group
5887 that currently owns the terminal being used to communicate with PROCESS.
5888 This is used for various commands in shell mode.
5889 If CURRENT_GROUP is lambda, that means send to the process group
5890 that currently owns the terminal, but only if it is NOT the shell itself.
5892 If NOMSG is zero, insert signal-announcements into process's buffers
5895 If we can, we try to signal PROCESS by sending control characters
5896 down the pty. This allows us to signal inferiors who have changed
5897 their uid, for which killpg would return an EPERM error. */
5900 process_send_signal (Lisp_Object process
, int signo
, Lisp_Object current_group
,
5904 register struct Lisp_Process
*p
;
5908 proc
= get_process (process
);
5909 p
= XPROCESS (proc
);
5911 if (!EQ (p
->type
, Qreal
))
5912 error ("Process %s is not a subprocess",
5915 error ("Process %s is not active",
5919 current_group
= Qnil
;
5921 /* If we are using pgrps, get a pgrp number and make it negative. */
5922 if (NILP (current_group
))
5923 /* Send the signal to the shell's process group. */
5927 #ifdef SIGNALS_VIA_CHARACTERS
5928 /* If possible, send signals to the entire pgrp
5929 by sending an input character to it. */
5932 cc_t
*sig_char
= NULL
;
5934 tcgetattr (p
->infd
, &t
);
5939 sig_char
= &t
.c_cc
[VINTR
];
5943 sig_char
= &t
.c_cc
[VQUIT
];
5947 #if defined (VSWTCH) && !defined (PREFER_VSUSP)
5948 sig_char
= &t
.c_cc
[VSWTCH
];
5950 sig_char
= &t
.c_cc
[VSUSP
];
5955 if (sig_char
&& *sig_char
!= CDISABLE
)
5957 send_process (proc
, (char *) sig_char
, 1, Qnil
);
5960 /* If we can't send the signal with a character,
5961 fall through and send it another way. */
5963 /* The code above may fall through if it can't
5964 handle the signal. */
5965 #endif /* defined (SIGNALS_VIA_CHARACTERS) */
5968 /* Get the current pgrp using the tty itself, if we have that.
5969 Otherwise, use the pty to get the pgrp.
5970 On pfa systems, saka@pfu.fujitsu.co.JP writes:
5971 "TIOCGPGRP symbol defined in sys/ioctl.h at E50.
5972 But, TIOCGPGRP does not work on E50 ;-P works fine on E60"
5973 His patch indicates that if TIOCGPGRP returns an error, then
5974 we should just assume that p->pid is also the process group id. */
5976 gid
= emacs_get_tty_pgrp (p
);
5979 /* If we can't get the information, assume
5980 the shell owns the tty. */
5983 /* It is not clear whether anything really can set GID to -1.
5984 Perhaps on some system one of those ioctls can or could do so.
5985 Or perhaps this is vestigial. */
5988 #else /* ! defined (TIOCGPGRP ) */
5989 /* Can't select pgrps on this system, so we know that
5990 the child itself heads the pgrp. */
5992 #endif /* ! defined (TIOCGPGRP ) */
5994 /* If current_group is lambda, and the shell owns the terminal,
5995 don't send any signal. */
5996 if (EQ (current_group
, Qlambda
) && gid
== p
->pid
)
6004 p
->raw_status_new
= 0;
6005 pset_status (p
, Qrun
);
6006 p
->tick
= ++process_tick
;
6009 status_notify (NULL
);
6010 redisplay_preserve_echo_area (13);
6013 #endif /* ! defined (SIGCONT) */
6017 flush_pending_output (p
->infd
);
6021 /* If we don't have process groups, send the signal to the immediate
6022 subprocess. That isn't really right, but it's better than any
6023 obvious alternative. */
6026 kill (p
->pid
, signo
);
6030 /* gid may be a pid, or minus a pgrp's number */
6032 if (!NILP (current_group
))
6034 if (ioctl (p
->infd
, TIOCSIGSEND
, signo
) == -1)
6035 EMACS_KILLPG (gid
, signo
);
6042 #else /* ! defined (TIOCSIGSEND) */
6043 EMACS_KILLPG (gid
, signo
);
6044 #endif /* ! defined (TIOCSIGSEND) */
6047 DEFUN ("interrupt-process", Finterrupt_process
, Sinterrupt_process
, 0, 2, 0,
6048 doc
: /* Interrupt process PROCESS.
6049 PROCESS may be a process, a buffer, or the name of a process or buffer.
6050 No arg or nil means current buffer's process.
6051 Second arg CURRENT-GROUP non-nil means send signal to
6052 the current process-group of the process's controlling terminal
6053 rather than to the process's own process group.
6054 If the process is a shell, this means interrupt current subjob
6055 rather than the shell.
6057 If CURRENT-GROUP is `lambda', and if the shell owns the terminal,
6058 don't send the signal. */)
6059 (Lisp_Object process
, Lisp_Object current_group
)
6061 process_send_signal (process
, SIGINT
, current_group
, 0);
6065 DEFUN ("kill-process", Fkill_process
, Skill_process
, 0, 2, 0,
6066 doc
: /* Kill process PROCESS. May be process or name of one.
6067 See function `interrupt-process' for more details on usage. */)
6068 (Lisp_Object process
, Lisp_Object current_group
)
6070 process_send_signal (process
, SIGKILL
, current_group
, 0);
6074 DEFUN ("quit-process", Fquit_process
, Squit_process
, 0, 2, 0,
6075 doc
: /* Send QUIT signal to process PROCESS. May be process or name of one.
6076 See function `interrupt-process' for more details on usage. */)
6077 (Lisp_Object process
, Lisp_Object current_group
)
6079 process_send_signal (process
, SIGQUIT
, current_group
, 0);
6083 DEFUN ("stop-process", Fstop_process
, Sstop_process
, 0, 2, 0,
6084 doc
: /* Stop process PROCESS. May be process or name of one.
6085 See function `interrupt-process' for more details on usage.
6086 If PROCESS is a network or serial process, inhibit handling of incoming
6088 (Lisp_Object process
, Lisp_Object current_group
)
6090 if (PROCESSP (process
) && (NETCONN_P (process
) || SERIALCONN_P (process
)))
6092 struct Lisp_Process
*p
;
6094 p
= XPROCESS (process
);
6095 if (NILP (p
->command
)
6098 FD_CLR (p
->infd
, &input_wait_mask
);
6099 FD_CLR (p
->infd
, &non_keyboard_wait_mask
);
6101 pset_command (p
, Qt
);
6105 error ("No SIGTSTP support");
6107 process_send_signal (process
, SIGTSTP
, current_group
, 0);
6112 DEFUN ("continue-process", Fcontinue_process
, Scontinue_process
, 0, 2, 0,
6113 doc
: /* Continue process PROCESS. May be process or name of one.
6114 See function `interrupt-process' for more details on usage.
6115 If PROCESS is a network or serial process, resume handling of incoming
6117 (Lisp_Object process
, Lisp_Object current_group
)
6119 if (PROCESSP (process
) && (NETCONN_P (process
) || SERIALCONN_P (process
)))
6121 struct Lisp_Process
*p
;
6123 p
= XPROCESS (process
);
6124 if (EQ (p
->command
, Qt
)
6126 && (!EQ (p
->filter
, Qt
) || EQ (p
->status
, Qlisten
)))
6128 FD_SET (p
->infd
, &input_wait_mask
);
6129 FD_SET (p
->infd
, &non_keyboard_wait_mask
);
6131 if (fd_info
[ p
->infd
].flags
& FILE_SERIAL
)
6132 PurgeComm (fd_info
[ p
->infd
].hnd
, PURGE_RXABORT
| PURGE_RXCLEAR
);
6133 #else /* not WINDOWSNT */
6134 tcflush (p
->infd
, TCIFLUSH
);
6135 #endif /* not WINDOWSNT */
6137 pset_command (p
, Qnil
);
6141 process_send_signal (process
, SIGCONT
, current_group
, 0);
6143 error ("No SIGCONT support");
6148 DEFUN ("signal-process", Fsignal_process
, Ssignal_process
,
6149 2, 2, "sProcess (name or number): \nnSignal code: ",
6150 doc
: /* Send PROCESS the signal with code SIGCODE.
6151 PROCESS may also be a number specifying the process id of the
6152 process to signal; in this case, the process need not be a child of
6154 SIGCODE may be an integer, or a symbol whose name is a signal name. */)
6155 (Lisp_Object process
, Lisp_Object sigcode
)
6159 if (STRINGP (process
))
6161 Lisp_Object tem
= Fget_process (process
);
6164 Lisp_Object process_number
=
6165 string_to_number (SSDATA (process
), 10, 1);
6166 if (INTEGERP (process_number
) || FLOATP (process_number
))
6167 tem
= process_number
;
6171 else if (!NUMBERP (process
))
6172 process
= get_process (process
);
6177 if (NUMBERP (process
))
6178 CONS_TO_INTEGER (process
, pid_t
, pid
);
6181 CHECK_PROCESS (process
);
6182 pid
= XPROCESS (process
)->pid
;
6184 error ("Cannot signal process %s", SDATA (XPROCESS (process
)->name
));
6187 #define parse_signal(NAME, VALUE) \
6188 else if (!xstrcasecmp (name, NAME)) \
6189 XSETINT (sigcode, VALUE)
6191 if (INTEGERP (sigcode
))
6192 CHECK_TYPE_RANGED_INTEGER (int, sigcode
);
6197 CHECK_SYMBOL (sigcode
);
6198 name
= SSDATA (SYMBOL_NAME (sigcode
));
6200 if (!strncmp (name
, "SIG", 3) || !strncmp (name
, "sig", 3))
6206 parse_signal ("usr1", SIGUSR1
);
6209 parse_signal ("usr2", SIGUSR2
);
6212 parse_signal ("term", SIGTERM
);
6215 parse_signal ("hup", SIGHUP
);
6218 parse_signal ("int", SIGINT
);
6221 parse_signal ("quit", SIGQUIT
);
6224 parse_signal ("ill", SIGILL
);
6227 parse_signal ("abrt", SIGABRT
);
6230 parse_signal ("emt", SIGEMT
);
6233 parse_signal ("kill", SIGKILL
);
6236 parse_signal ("fpe", SIGFPE
);
6239 parse_signal ("bus", SIGBUS
);
6242 parse_signal ("segv", SIGSEGV
);
6245 parse_signal ("sys", SIGSYS
);
6248 parse_signal ("pipe", SIGPIPE
);
6251 parse_signal ("alrm", SIGALRM
);
6254 parse_signal ("urg", SIGURG
);
6257 parse_signal ("stop", SIGSTOP
);
6260 parse_signal ("tstp", SIGTSTP
);
6263 parse_signal ("cont", SIGCONT
);
6266 parse_signal ("chld", SIGCHLD
);
6269 parse_signal ("ttin", SIGTTIN
);
6272 parse_signal ("ttou", SIGTTOU
);
6275 parse_signal ("io", SIGIO
);
6278 parse_signal ("xcpu", SIGXCPU
);
6281 parse_signal ("xfsz", SIGXFSZ
);
6284 parse_signal ("vtalrm", SIGVTALRM
);
6287 parse_signal ("prof", SIGPROF
);
6290 parse_signal ("winch", SIGWINCH
);
6293 parse_signal ("info", SIGINFO
);
6296 error ("Undefined signal name %s", name
);
6301 return make_number (kill (pid
, XINT (sigcode
)));
6304 DEFUN ("process-send-eof", Fprocess_send_eof
, Sprocess_send_eof
, 0, 1, 0,
6305 doc
: /* Make PROCESS see end-of-file in its input.
6306 EOF comes after any text already sent to it.
6307 PROCESS may be a process, a buffer, the name of a process or buffer, or
6308 nil, indicating the current buffer's process.
6309 If PROCESS is a network connection, or is a process communicating
6310 through a pipe (as opposed to a pty), then you cannot send any more
6311 text to PROCESS after you call this function.
6312 If PROCESS is a serial process, wait until all output written to the
6313 process has been transmitted to the serial port. */)
6314 (Lisp_Object process
)
6317 struct coding_system
*coding
;
6319 if (DATAGRAM_CONN_P (process
))
6322 proc
= get_process (process
);
6323 coding
= proc_encode_coding_system
[XPROCESS (proc
)->outfd
];
6325 /* Make sure the process is really alive. */
6326 if (XPROCESS (proc
)->raw_status_new
)
6327 update_status (XPROCESS (proc
));
6328 if (! EQ (XPROCESS (proc
)->status
, Qrun
))
6329 error ("Process %s not running", SDATA (XPROCESS (proc
)->name
));
6331 if (CODING_REQUIRE_FLUSHING (coding
))
6333 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
6334 send_process (proc
, "", 0, Qnil
);
6337 if (XPROCESS (proc
)->pty_flag
)
6338 send_process (proc
, "\004", 1, Qnil
);
6339 else if (EQ (XPROCESS (proc
)->type
, Qserial
))
6342 if (tcdrain (XPROCESS (proc
)->outfd
) != 0)
6343 error ("tcdrain() failed: %s", emacs_strerror (errno
));
6344 #endif /* not WINDOWSNT */
6345 /* Do nothing on Windows because writes are blocking. */
6349 int old_outfd
, new_outfd
;
6351 #ifdef HAVE_SHUTDOWN
6352 /* If this is a network connection, or socketpair is used
6353 for communication with the subprocess, call shutdown to cause EOF.
6354 (In some old system, shutdown to socketpair doesn't work.
6355 Then we just can't win.) */
6356 if (EQ (XPROCESS (proc
)->type
, Qnetwork
)
6357 || XPROCESS (proc
)->outfd
== XPROCESS (proc
)->infd
)
6358 shutdown (XPROCESS (proc
)->outfd
, 1);
6359 /* In case of socketpair, outfd == infd, so don't close it. */
6360 if (XPROCESS (proc
)->outfd
!= XPROCESS (proc
)->infd
)
6361 emacs_close (XPROCESS (proc
)->outfd
);
6362 #else /* not HAVE_SHUTDOWN */
6363 emacs_close (XPROCESS (proc
)->outfd
);
6364 #endif /* not HAVE_SHUTDOWN */
6365 new_outfd
= emacs_open (NULL_DEVICE
, O_WRONLY
, 0);
6368 old_outfd
= XPROCESS (proc
)->outfd
;
6370 if (!proc_encode_coding_system
[new_outfd
])
6371 proc_encode_coding_system
[new_outfd
]
6372 = xmalloc (sizeof (struct coding_system
));
6373 memcpy (proc_encode_coding_system
[new_outfd
],
6374 proc_encode_coding_system
[old_outfd
],
6375 sizeof (struct coding_system
));
6376 memset (proc_encode_coding_system
[old_outfd
], 0,
6377 sizeof (struct coding_system
));
6379 XPROCESS (proc
)->outfd
= new_outfd
;
6384 /* On receipt of a signal that a child status has changed, loop asking
6385 about children with changed statuses until the system says there
6388 All we do is change the status; we do not run sentinels or print
6389 notifications. That is saved for the next time keyboard input is
6390 done, in order to avoid timing errors.
6392 ** WARNING: this can be called during garbage collection.
6393 Therefore, it must not be fooled by the presence of mark bits in
6396 ** USG WARNING: Although it is not obvious from the documentation
6397 in signal(2), on a USG system the SIGCLD handler MUST NOT call
6398 signal() before executing at least one wait(), otherwise the
6399 handler will be called again, resulting in an infinite loop. The
6400 relevant portion of the documentation reads "SIGCLD signals will be
6401 queued and the signal-catching function will be continually
6402 reentered until the queue is empty". Invoking signal() causes the
6403 kernel to reexamine the SIGCLD queue. Fred Fish, UniSoft Systems
6406 ** Malloc WARNING: This should never call malloc either directly or
6407 indirectly; if it does, that is a bug */
6411 /* Record one child's changed status. Return true if a child was found. */
6413 record_child_status_change (void)
6416 struct Lisp_Process
*p
;
6422 pid
= waitpid (-1, &w
, WNOHANG
| WUNTRACED
);
6423 while (pid
< 0 && errno
== EINTR
);
6425 /* PID == 0 means no processes found, PID == -1 means a real failure.
6426 Either way, we have done all our job. */
6430 /* Find the process that signaled us, and record its status. */
6432 /* The process can have been deleted by Fdelete_process. */
6433 for (tail
= deleted_pid_list
; CONSP (tail
); tail
= XCDR (tail
))
6435 Lisp_Object xpid
= XCAR (tail
);
6436 if ((INTEGERP (xpid
) && pid
== XINT (xpid
))
6437 || (FLOATP (xpid
) && pid
== XFLOAT_DATA (xpid
)))
6439 XSETCAR (tail
, Qnil
);
6444 /* Otherwise, if it is asynchronous, it is in Vprocess_alist. */
6446 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
6448 proc
= XCDR (XCAR (tail
));
6449 p
= XPROCESS (proc
);
6450 if (EQ (p
->type
, Qreal
) && p
->pid
== pid
)
6455 /* Look for an asynchronous process whose pid hasn't been filled
6458 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
6460 proc
= XCDR (XCAR (tail
));
6461 p
= XPROCESS (proc
);
6467 /* Change the status of the process that was found. */
6470 int clear_desc_flag
= 0;
6472 p
->tick
= ++process_tick
;
6474 p
->raw_status_new
= 1;
6476 /* If process has terminated, stop waiting for its output. */
6477 if ((WIFSIGNALED (w
) || WIFEXITED (w
))
6479 clear_desc_flag
= 1;
6481 /* We use clear_desc_flag to avoid a compiler bug in Microsoft C. */
6482 if (clear_desc_flag
)
6484 FD_CLR (p
->infd
, &input_wait_mask
);
6485 FD_CLR (p
->infd
, &non_keyboard_wait_mask
);
6488 /* Tell wait_reading_process_output that it needs to wake up and
6490 if (input_available_clear_time
)
6491 *input_available_clear_time
= make_emacs_time (0, 0);
6493 /* There was no asynchronous process found for that pid: we have
6494 a synchronous process. */
6497 synch_process_alive
= 0;
6499 /* Report the status of the synchronous process. */
6501 synch_process_retcode
= WEXITSTATUS (w
);
6502 else if (WIFSIGNALED (w
))
6503 synch_process_termsig
= WTERMSIG (w
);
6505 /* Tell wait_reading_process_output that it needs to wake up and
6507 if (input_available_clear_time
)
6508 *input_available_clear_time
= make_emacs_time (0, 0);
6514 /* On some systems, the SIGCHLD handler must return right away. If
6515 any more processes want to signal us, we will get another signal.
6516 Otherwise, loop around to use up all the processes that have
6517 something to tell us. */
6518 #if (defined WINDOWSNT \
6519 || (defined USG && !defined GNU_LINUX \
6520 && !(defined HPUX && defined WNOHANG)))
6521 enum { CAN_HANDLE_MULTIPLE_CHILDREN
= 1 };
6523 enum { CAN_HANDLE_MULTIPLE_CHILDREN
= 0 };
6527 handle_child_signal (int sig
)
6529 while (record_child_status_change () && CAN_HANDLE_MULTIPLE_CHILDREN
)
6534 deliver_child_signal (int sig
)
6536 handle_on_main_thread (sig
, handle_child_signal
);
6539 #endif /* SIGCHLD */
6543 exec_sentinel_unwind (Lisp_Object data
)
6545 pset_sentinel (XPROCESS (XCAR (data
)), XCDR (data
));
6550 exec_sentinel_error_handler (Lisp_Object error_val
)
6552 cmd_error_internal (error_val
, "error in process sentinel: ");
6554 update_echo_area ();
6555 Fsleep_for (make_number (2), Qnil
);
6560 exec_sentinel (Lisp_Object proc
, Lisp_Object reason
)
6562 Lisp_Object sentinel
, odeactivate
;
6563 struct Lisp_Process
*p
= XPROCESS (proc
);
6564 ptrdiff_t count
= SPECPDL_INDEX ();
6565 bool outer_running_asynch_code
= running_asynch_code
;
6566 int waiting
= waiting_for_user_input_p
;
6568 if (inhibit_sentinels
)
6571 /* No need to gcpro these, because all we do with them later
6572 is test them for EQness, and none of them should be a string. */
6573 odeactivate
= Vdeactivate_mark
;
6575 Lisp_Object obuffer
, okeymap
;
6576 XSETBUFFER (obuffer
, current_buffer
);
6577 okeymap
= BVAR (current_buffer
, keymap
);
6580 /* There's no good reason to let sentinels change the current
6581 buffer, and many callers of accept-process-output, sit-for, and
6582 friends don't expect current-buffer to be changed from under them. */
6583 record_unwind_current_buffer ();
6585 sentinel
= p
->sentinel
;
6586 if (NILP (sentinel
))
6589 /* Zilch the sentinel while it's running, to avoid recursive invocations;
6590 assure that it gets restored no matter how the sentinel exits. */
6591 pset_sentinel (p
, Qnil
);
6592 record_unwind_protect (exec_sentinel_unwind
, Fcons (proc
, sentinel
));
6593 /* Inhibit quit so that random quits don't screw up a running filter. */
6594 specbind (Qinhibit_quit
, Qt
);
6595 specbind (Qlast_nonmenu_event
, Qt
); /* Why? --Stef */
6597 /* In case we get recursively called,
6598 and we already saved the match data nonrecursively,
6599 save the same match data in safely recursive fashion. */
6600 if (outer_running_asynch_code
)
6603 tem
= Fmatch_data (Qnil
, Qnil
, Qnil
);
6604 restore_search_regs ();
6605 record_unwind_save_match_data ();
6606 Fset_match_data (tem
, Qt
);
6609 /* For speed, if a search happens within this code,
6610 save the match data in a special nonrecursive fashion. */
6611 running_asynch_code
= 1;
6613 internal_condition_case_1 (read_process_output_call
,
6615 Fcons (proc
, Fcons (reason
, Qnil
))),
6616 !NILP (Vdebug_on_error
) ? Qnil
: Qerror
,
6617 exec_sentinel_error_handler
);
6619 /* If we saved the match data nonrecursively, restore it now. */
6620 restore_search_regs ();
6621 running_asynch_code
= outer_running_asynch_code
;
6623 Vdeactivate_mark
= odeactivate
;
6625 /* Restore waiting_for_user_input_p as it was
6626 when we were called, in case the filter clobbered it. */
6627 waiting_for_user_input_p
= waiting
;
6630 if (! EQ (Fcurrent_buffer (), obuffer
)
6631 || ! EQ (current_buffer
->keymap
, okeymap
))
6633 /* But do it only if the caller is actually going to read events.
6634 Otherwise there's no need to make him wake up, and it could
6635 cause trouble (for example it would make sit_for return). */
6636 if (waiting_for_user_input_p
== -1)
6637 record_asynch_buffer_change ();
6639 unbind_to (count
, Qnil
);
6642 /* Report all recent events of a change in process status
6643 (either run the sentinel or output a message).
6644 This is usually done while Emacs is waiting for keyboard input
6645 but can be done at other times. */
6648 status_notify (struct Lisp_Process
*deleting_process
)
6650 register Lisp_Object proc
, buffer
;
6651 Lisp_Object tail
, msg
;
6652 struct gcpro gcpro1
, gcpro2
;
6656 /* We need to gcpro tail; if read_process_output calls a filter
6657 which deletes a process and removes the cons to which tail points
6658 from Vprocess_alist, and then causes a GC, tail is an unprotected
6662 /* Set this now, so that if new processes are created by sentinels
6663 that we run, we get called again to handle their status changes. */
6664 update_tick
= process_tick
;
6666 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
6669 register struct Lisp_Process
*p
;
6671 proc
= Fcdr (XCAR (tail
));
6672 p
= XPROCESS (proc
);
6674 if (p
->tick
!= p
->update_tick
)
6676 p
->update_tick
= p
->tick
;
6678 /* If process is still active, read any output that remains. */
6679 while (! EQ (p
->filter
, Qt
)
6680 && ! EQ (p
->status
, Qconnect
)
6681 && ! EQ (p
->status
, Qlisten
)
6682 /* Network or serial process not stopped: */
6683 && ! EQ (p
->command
, Qt
)
6685 && p
!= deleting_process
6686 && read_process_output (proc
, p
->infd
) > 0);
6690 /* Get the text to use for the message. */
6691 if (p
->raw_status_new
)
6693 msg
= status_message (p
);
6695 /* If process is terminated, deactivate it or delete it. */
6697 if (CONSP (p
->status
))
6698 symbol
= XCAR (p
->status
);
6700 if (EQ (symbol
, Qsignal
) || EQ (symbol
, Qexit
)
6701 || EQ (symbol
, Qclosed
))
6703 if (delete_exited_processes
)
6704 remove_process (proc
);
6706 deactivate_process (proc
);
6709 /* The actions above may have further incremented p->tick.
6710 So set p->update_tick again
6711 so that an error in the sentinel will not cause
6712 this code to be run again. */
6713 p
->update_tick
= p
->tick
;
6714 /* Now output the message suitably. */
6715 if (!NILP (p
->sentinel
))
6716 exec_sentinel (proc
, msg
);
6717 /* Don't bother with a message in the buffer
6718 when a process becomes runnable. */
6719 else if (!EQ (symbol
, Qrun
) && !NILP (buffer
))
6722 struct buffer
*old
= current_buffer
;
6723 ptrdiff_t opoint
, opoint_byte
;
6724 ptrdiff_t before
, before_byte
;
6726 /* Avoid error if buffer is deleted
6727 (probably that's why the process is dead, too) */
6728 if (NILP (BVAR (XBUFFER (buffer
), name
)))
6730 Fset_buffer (buffer
);
6733 opoint_byte
= PT_BYTE
;
6734 /* Insert new output into buffer
6735 at the current end-of-output marker,
6736 thus preserving logical ordering of input and output. */
6737 if (XMARKER (p
->mark
)->buffer
)
6738 Fgoto_char (p
->mark
);
6740 SET_PT_BOTH (ZV
, ZV_BYTE
);
6743 before_byte
= PT_BYTE
;
6745 tem
= BVAR (current_buffer
, read_only
);
6746 bset_read_only (current_buffer
, Qnil
);
6747 insert_string ("\nProcess ");
6748 { /* FIXME: temporary kludge */
6749 Lisp_Object tem2
= p
->name
; Finsert (1, &tem2
); }
6750 insert_string (" ");
6752 bset_read_only (current_buffer
, tem
);
6753 set_marker_both (p
->mark
, p
->buffer
, PT
, PT_BYTE
);
6755 if (opoint
>= before
)
6756 SET_PT_BOTH (opoint
+ (PT
- before
),
6757 opoint_byte
+ (PT_BYTE
- before_byte
));
6759 SET_PT_BOTH (opoint
, opoint_byte
);
6761 set_buffer_internal (old
);
6766 update_mode_lines
++; /* in case buffers use %s in mode-line-format */
6771 DEFUN ("set-process-coding-system", Fset_process_coding_system
,
6772 Sset_process_coding_system
, 1, 3, 0,
6773 doc
: /* Set coding systems of PROCESS to DECODING and ENCODING.
6774 DECODING will be used to decode subprocess output and ENCODING to
6775 encode subprocess input. */)
6776 (register Lisp_Object process
, Lisp_Object decoding
, Lisp_Object encoding
)
6778 register struct Lisp_Process
*p
;
6780 CHECK_PROCESS (process
);
6781 p
= XPROCESS (process
);
6783 error ("Input file descriptor of %s closed", SDATA (p
->name
));
6785 error ("Output file descriptor of %s closed", SDATA (p
->name
));
6786 Fcheck_coding_system (decoding
);
6787 Fcheck_coding_system (encoding
);
6788 encoding
= coding_inherit_eol_type (encoding
, Qnil
);
6789 pset_decode_coding_system (p
, decoding
);
6790 pset_encode_coding_system (p
, encoding
);
6791 setup_process_coding_systems (process
);
6796 DEFUN ("process-coding-system",
6797 Fprocess_coding_system
, Sprocess_coding_system
, 1, 1, 0,
6798 doc
: /* Return a cons of coding systems for decoding and encoding of PROCESS. */)
6799 (register Lisp_Object process
)
6801 CHECK_PROCESS (process
);
6802 return Fcons (XPROCESS (process
)->decode_coding_system
,
6803 XPROCESS (process
)->encode_coding_system
);
6806 DEFUN ("set-process-filter-multibyte", Fset_process_filter_multibyte
,
6807 Sset_process_filter_multibyte
, 2, 2, 0,
6808 doc
: /* Set multibyteness of the strings given to PROCESS's filter.
6809 If FLAG is non-nil, the filter is given multibyte strings.
6810 If FLAG is nil, the filter is given unibyte strings. In this case,
6811 all character code conversion except for end-of-line conversion is
6813 (Lisp_Object process
, Lisp_Object flag
)
6815 register struct Lisp_Process
*p
;
6817 CHECK_PROCESS (process
);
6818 p
= XPROCESS (process
);
6820 pset_decode_coding_system
6821 (p
, raw_text_coding_system (p
->decode_coding_system
));
6822 setup_process_coding_systems (process
);
6827 DEFUN ("process-filter-multibyte-p", Fprocess_filter_multibyte_p
,
6828 Sprocess_filter_multibyte_p
, 1, 1, 0,
6829 doc
: /* Return t if a multibyte string is given to PROCESS's filter.*/)
6830 (Lisp_Object process
)
6832 register struct Lisp_Process
*p
;
6833 struct coding_system
*coding
;
6835 CHECK_PROCESS (process
);
6836 p
= XPROCESS (process
);
6837 coding
= proc_decode_coding_system
[p
->infd
];
6838 return (CODING_FOR_UNIBYTE (coding
) ? Qnil
: Qt
);
6847 add_gpm_wait_descriptor (int desc
)
6849 add_keyboard_wait_descriptor (desc
);
6853 delete_gpm_wait_descriptor (int desc
)
6855 delete_keyboard_wait_descriptor (desc
);
6862 /* Return nonzero if *MASK has a bit set
6863 that corresponds to one of the keyboard input descriptors. */
6866 keyboard_bit_set (fd_set
*mask
)
6870 for (fd
= 0; fd
<= max_input_desc
; fd
++)
6871 if (FD_ISSET (fd
, mask
) && FD_ISSET (fd
, &input_wait_mask
)
6872 && !FD_ISSET (fd
, &non_keyboard_wait_mask
))
6879 #else /* not subprocesses */
6881 /* Defined on msdos.c. */
6882 extern int sys_select (int, SELECT_TYPE
*, SELECT_TYPE
*, SELECT_TYPE
*,
6883 EMACS_TIME
*, void *);
6885 /* Implementation of wait_reading_process_output, assuming that there
6886 are no subprocesses. Used only by the MS-DOS build.
6888 Wait for timeout to elapse and/or keyboard input to be available.
6892 If negative, gobble data immediately available but don't wait for any.
6895 an additional duration to wait, measured in nanoseconds
6896 If TIME_LIMIT is zero, then:
6897 If NSECS == 0, there is no limit.
6898 If NSECS > 0, the timeout consists of NSECS only.
6899 If NSECS < 0, gobble data immediately, as if TIME_LIMIT were negative.
6902 0 to ignore keyboard input, or
6903 1 to return when input is available, or
6904 -1 means caller will actually read the input, so don't throw to
6907 see full version for other parameters. We know that wait_proc will
6908 always be NULL, since `subprocesses' isn't defined.
6910 DO_DISPLAY != 0 means redisplay should be done to show subprocess
6911 output that arrives.
6913 Return true if we received input from any process. */
6916 wait_reading_process_output (intmax_t time_limit
, int nsecs
, int read_kbd
,
6918 Lisp_Object wait_for_cell
,
6919 struct Lisp_Process
*wait_proc
, int just_wait_proc
)
6922 EMACS_TIME end_time
, timeout
;
6929 else if (TYPE_MAXIMUM (time_t) < time_limit
)
6930 time_limit
= TYPE_MAXIMUM (time_t);
6932 /* What does time_limit really mean? */
6933 if (time_limit
|| 0 < nsecs
)
6935 timeout
= make_emacs_time (time_limit
, nsecs
);
6936 end_time
= add_emacs_time (current_emacs_time (), timeout
);
6939 /* Turn off periodic alarms (in case they are in use)
6940 and then turn off any other atimers,
6941 because the select emulator uses alarms. */
6943 turn_on_atimers (0);
6947 int timeout_reduced_for_timers
= 0;
6948 SELECT_TYPE waitchannels
;
6951 /* If calling from keyboard input, do not quit
6952 since we want to return C-g as an input character.
6953 Otherwise, do pending quit if requested. */
6957 /* Exit now if the cell we're waiting for became non-nil. */
6958 if (! NILP (wait_for_cell
) && ! NILP (XCAR (wait_for_cell
)))
6961 /* Compute time from now till when time limit is up */
6962 /* Exit if already run out */
6965 /* A negative timeout means
6966 gobble output available now
6967 but don't wait at all. */
6969 timeout
= make_emacs_time (0, 0);
6971 else if (time_limit
|| 0 < nsecs
)
6973 EMACS_TIME now
= current_emacs_time ();
6974 if (EMACS_TIME_LE (end_time
, now
))
6976 timeout
= sub_emacs_time (end_time
, now
);
6980 timeout
= make_emacs_time (100000, 0);
6983 /* If our caller will not immediately handle keyboard events,
6984 run timer events directly.
6985 (Callers that will immediately read keyboard events
6986 call timer_delay on their own.) */
6987 if (NILP (wait_for_cell
))
6989 EMACS_TIME timer_delay
;
6993 int old_timers_run
= timers_run
;
6994 timer_delay
= timer_check ();
6995 if (timers_run
!= old_timers_run
&& do_display
)
6996 /* We must retry, since a timer may have requeued itself
6997 and that could alter the time delay. */
6998 redisplay_preserve_echo_area (14);
7002 while (!detect_input_pending ());
7004 /* If there is unread keyboard input, also return. */
7006 && requeued_events_pending_p ())
7009 if (EMACS_TIME_VALID_P (timer_delay
) && 0 <= nsecs
)
7011 if (EMACS_TIME_LT (timer_delay
, timeout
))
7013 timeout
= timer_delay
;
7014 timeout_reduced_for_timers
= 1;
7019 /* Cause C-g and alarm signals to take immediate action,
7020 and cause input available signals to zero out timeout. */
7022 set_waiting_for_input (&timeout
);
7024 /* If a frame has been newly mapped and needs updating,
7025 reprocess its display stuff. */
7026 if (frame_garbaged
&& do_display
)
7028 clear_waiting_for_input ();
7029 redisplay_preserve_echo_area (15);
7031 set_waiting_for_input (&timeout
);
7034 /* Wait till there is something to do. */
7035 FD_ZERO (&waitchannels
);
7036 if (read_kbd
&& detect_input_pending ())
7040 if (read_kbd
|| !NILP (wait_for_cell
))
7041 FD_SET (0, &waitchannels
);
7042 nfds
= pselect (1, &waitchannels
, NULL
, NULL
, &timeout
, NULL
);
7047 /* Make C-g and alarm signals set flags again */
7048 clear_waiting_for_input ();
7050 /* If we woke up due to SIGWINCH, actually change size now. */
7051 do_pending_window_change (0);
7053 if ((time_limit
|| nsecs
) && nfds
== 0 && ! timeout_reduced_for_timers
)
7054 /* We waited the full specified time, so return now. */
7059 /* If the system call was interrupted, then go around the
7061 if (xerrno
== EINTR
)
7062 FD_ZERO (&waitchannels
);
7064 error ("select error: %s", emacs_strerror (xerrno
));
7067 /* Check for keyboard input */
7070 && detect_input_pending_run_timers (do_display
))
7072 swallow_events (do_display
);
7073 if (detect_input_pending_run_timers (do_display
))
7077 /* If there is unread keyboard input, also return. */
7079 && requeued_events_pending_p ())
7082 /* If wait_for_cell. check for keyboard input
7083 but don't run any timers.
7084 ??? (It seems wrong to me to check for keyboard
7085 input at all when wait_for_cell, but the code
7086 has been this way since July 1994.
7087 Try changing this after version 19.31.) */
7088 if (! NILP (wait_for_cell
)
7089 && detect_input_pending ())
7091 swallow_events (do_display
);
7092 if (detect_input_pending ())
7096 /* Exit now if the cell we're waiting for became non-nil. */
7097 if (! NILP (wait_for_cell
) && ! NILP (XCAR (wait_for_cell
)))
7106 #endif /* not subprocesses */
7108 /* The following functions are needed even if async subprocesses are
7109 not supported. Some of them are no-op stubs in that case. */
7111 /* Add DESC to the set of keyboard input descriptors. */
7114 add_keyboard_wait_descriptor (int desc
)
7116 #ifdef subprocesses /* actually means "not MSDOS" */
7117 FD_SET (desc
, &input_wait_mask
);
7118 FD_SET (desc
, &non_process_wait_mask
);
7119 if (desc
> max_input_desc
)
7120 max_input_desc
= desc
;
7124 /* From now on, do not expect DESC to give keyboard input. */
7127 delete_keyboard_wait_descriptor (int desc
)
7131 int lim
= max_input_desc
;
7133 FD_CLR (desc
, &input_wait_mask
);
7134 FD_CLR (desc
, &non_process_wait_mask
);
7136 if (desc
== max_input_desc
)
7137 for (fd
= 0; fd
< lim
; fd
++)
7138 if (FD_ISSET (fd
, &input_wait_mask
) || FD_ISSET (fd
, &write_mask
))
7139 max_input_desc
= fd
;
7143 /* Setup coding systems of PROCESS. */
7146 setup_process_coding_systems (Lisp_Object process
)
7149 struct Lisp_Process
*p
= XPROCESS (process
);
7151 int outch
= p
->outfd
;
7152 Lisp_Object coding_system
;
7154 if (inch
< 0 || outch
< 0)
7157 if (!proc_decode_coding_system
[inch
])
7158 proc_decode_coding_system
[inch
] = xmalloc (sizeof (struct coding_system
));
7159 coding_system
= p
->decode_coding_system
;
7160 if (! NILP (p
->filter
))
7162 else if (BUFFERP (p
->buffer
))
7164 if (NILP (BVAR (XBUFFER (p
->buffer
), enable_multibyte_characters
)))
7165 coding_system
= raw_text_coding_system (coding_system
);
7167 setup_coding_system (coding_system
, proc_decode_coding_system
[inch
]);
7169 if (!proc_encode_coding_system
[outch
])
7170 proc_encode_coding_system
[outch
] = xmalloc (sizeof (struct coding_system
));
7171 setup_coding_system (p
->encode_coding_system
,
7172 proc_encode_coding_system
[outch
]);
7176 /* Close all descriptors currently in use for communication
7177 with subprocess. This is used in a newly-forked subprocess
7178 to get rid of irrelevant descriptors. */
7181 close_process_descs (void)
7185 for (i
= 0; i
< MAXDESC
; i
++)
7187 Lisp_Object process
;
7188 process
= chan_process
[i
];
7189 if (!NILP (process
))
7191 int in
= XPROCESS (process
)->infd
;
7192 int out
= XPROCESS (process
)->outfd
;
7195 if (out
>= 0 && in
!= out
)
7202 DEFUN ("get-buffer-process", Fget_buffer_process
, Sget_buffer_process
, 1, 1, 0,
7203 doc
: /* Return the (or a) process associated with BUFFER.
7204 BUFFER may be a buffer or the name of one. */)
7205 (register Lisp_Object buffer
)
7208 register Lisp_Object buf
, tail
, proc
;
7210 if (NILP (buffer
)) return Qnil
;
7211 buf
= Fget_buffer (buffer
);
7212 if (NILP (buf
)) return Qnil
;
7214 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
7216 proc
= Fcdr (XCAR (tail
));
7217 if (PROCESSP (proc
) && EQ (XPROCESS (proc
)->buffer
, buf
))
7220 #endif /* subprocesses */
7224 DEFUN ("process-inherit-coding-system-flag",
7225 Fprocess_inherit_coding_system_flag
, Sprocess_inherit_coding_system_flag
,
7227 doc
: /* Return the value of inherit-coding-system flag for PROCESS.
7228 If this flag is t, `buffer-file-coding-system' of the buffer
7229 associated with PROCESS will inherit the coding system used to decode
7230 the process output. */)
7231 (register Lisp_Object process
)
7234 CHECK_PROCESS (process
);
7235 return XPROCESS (process
)->inherit_coding_system_flag
? Qt
: Qnil
;
7237 /* Ignore the argument and return the value of
7238 inherit-process-coding-system. */
7239 return inherit_process_coding_system
? Qt
: Qnil
;
7243 /* Kill all processes associated with `buffer'.
7244 If `buffer' is nil, kill all processes */
7247 kill_buffer_processes (Lisp_Object buffer
)
7250 Lisp_Object tail
, proc
;
7252 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
7254 proc
= XCDR (XCAR (tail
));
7256 && (NILP (buffer
) || EQ (XPROCESS (proc
)->buffer
, buffer
)))
7258 if (NETCONN_P (proc
) || SERIALCONN_P (proc
))
7259 Fdelete_process (proc
);
7260 else if (XPROCESS (proc
)->infd
>= 0)
7261 process_send_signal (proc
, SIGHUP
, Qnil
, 1);
7264 #else /* subprocesses */
7265 /* Since we have no subprocesses, this does nothing. */
7266 #endif /* subprocesses */
7269 DEFUN ("waiting-for-user-input-p", Fwaiting_for_user_input_p
,
7270 Swaiting_for_user_input_p
, 0, 0, 0,
7271 doc
: /* Returns non-nil if Emacs is waiting for input from the user.
7272 This is intended for use by asynchronous process output filters and sentinels. */)
7276 return (waiting_for_user_input_p
? Qt
: Qnil
);
7282 /* Stop reading input from keyboard sources. */
7285 hold_keyboard_input (void)
7290 /* Resume reading input from keyboard sources. */
7293 unhold_keyboard_input (void)
7298 /* Return non-zero if keyboard input is on hold, zero otherwise. */
7301 kbd_on_hold_p (void)
7303 return kbd_is_on_hold
;
7307 /* Enumeration of and access to system processes a-la ps(1). */
7309 DEFUN ("list-system-processes", Flist_system_processes
, Slist_system_processes
,
7311 doc
: /* Return a list of numerical process IDs of all running processes.
7312 If this functionality is unsupported, return nil.
7314 See `process-attributes' for getting attributes of a process given its ID. */)
7317 return list_system_processes ();
7320 DEFUN ("process-attributes", Fprocess_attributes
,
7321 Sprocess_attributes
, 1, 1, 0,
7322 doc
: /* Return attributes of the process given by its PID, a number.
7324 Value is an alist where each element is a cons cell of the form
7328 If this functionality is unsupported, the value is nil.
7330 See `list-system-processes' for getting a list of all process IDs.
7332 The KEYs of the attributes that this function may return are listed
7333 below, together with the type of the associated VALUE (in parentheses).
7334 Not all platforms support all of these attributes; unsupported
7335 attributes will not appear in the returned alist.
7336 Unless explicitly indicated otherwise, numbers can have either
7337 integer or floating point values.
7339 euid -- Effective user User ID of the process (number)
7340 user -- User name corresponding to euid (string)
7341 egid -- Effective user Group ID of the process (number)
7342 group -- Group name corresponding to egid (string)
7343 comm -- Command name (executable name only) (string)
7344 state -- Process state code, such as "S", "R", or "T" (string)
7345 ppid -- Parent process ID (number)
7346 pgrp -- Process group ID (number)
7347 sess -- Session ID, i.e. process ID of session leader (number)
7348 ttname -- Controlling tty name (string)
7349 tpgid -- ID of foreground process group on the process's tty (number)
7350 minflt -- number of minor page faults (number)
7351 majflt -- number of major page faults (number)
7352 cminflt -- cumulative number of minor page faults (number)
7353 cmajflt -- cumulative number of major page faults (number)
7354 utime -- user time used by the process, in (current-time) format,
7355 which is a list of integers (HIGH LOW USEC PSEC)
7356 stime -- system time used by the process (current-time)
7357 time -- sum of utime and stime (current-time)
7358 cutime -- user time used by the process and its children (current-time)
7359 cstime -- system time used by the process and its children (current-time)
7360 ctime -- sum of cutime and cstime (current-time)
7361 pri -- priority of the process (number)
7362 nice -- nice value of the process (number)
7363 thcount -- process thread count (number)
7364 start -- time the process started (current-time)
7365 vsize -- virtual memory size of the process in KB's (number)
7366 rss -- resident set size of the process in KB's (number)
7367 etime -- elapsed time the process is running, in (HIGH LOW USEC PSEC) format
7368 pcpu -- percents of CPU time used by the process (floating-point number)
7369 pmem -- percents of total physical memory used by process's resident set
7370 (floating-point number)
7371 args -- command line which invoked the process (string). */)
7374 return system_process_attributes (pid
);
7378 /* This is not called "init_process" because that is the name of a
7379 Mach system call, so it would cause problems on Darwin systems. */
7381 init_process_emacs (void)
7386 inhibit_sentinels
= 0;
7390 if (! noninteractive
|| initialized
)
7392 signal (SIGCHLD
, deliver_child_signal
);
7395 FD_ZERO (&input_wait_mask
);
7396 FD_ZERO (&non_keyboard_wait_mask
);
7397 FD_ZERO (&non_process_wait_mask
);
7398 FD_ZERO (&write_mask
);
7399 max_process_desc
= 0;
7400 memset (fd_callback_info
, 0, sizeof (fd_callback_info
));
7402 #ifdef NON_BLOCKING_CONNECT
7403 FD_ZERO (&connect_wait_mask
);
7404 num_pending_connects
= 0;
7407 #ifdef ADAPTIVE_READ_BUFFERING
7408 process_output_delay_count
= 0;
7409 process_output_skip
= 0;
7412 /* Don't do this, it caused infinite select loops. The display
7413 method should call add_keyboard_wait_descriptor on stdin if it
7416 FD_SET (0, &input_wait_mask
);
7419 Vprocess_alist
= Qnil
;
7421 deleted_pid_list
= Qnil
;
7423 for (i
= 0; i
< MAXDESC
; i
++)
7425 chan_process
[i
] = Qnil
;
7426 proc_buffered_char
[i
] = -1;
7428 memset (proc_decode_coding_system
, 0, sizeof proc_decode_coding_system
);
7429 memset (proc_encode_coding_system
, 0, sizeof proc_encode_coding_system
);
7430 #ifdef DATAGRAM_SOCKETS
7431 memset (datagram_address
, 0, sizeof datagram_address
);
7435 Lisp_Object subfeatures
= Qnil
;
7436 const struct socket_options
*sopt
;
7438 #define ADD_SUBFEATURE(key, val) \
7439 subfeatures = pure_cons (pure_cons (key, pure_cons (val, Qnil)), subfeatures)
7441 #ifdef NON_BLOCKING_CONNECT
7442 ADD_SUBFEATURE (QCnowait
, Qt
);
7444 #ifdef DATAGRAM_SOCKETS
7445 ADD_SUBFEATURE (QCtype
, Qdatagram
);
7447 #ifdef HAVE_SEQPACKET
7448 ADD_SUBFEATURE (QCtype
, Qseqpacket
);
7450 #ifdef HAVE_LOCAL_SOCKETS
7451 ADD_SUBFEATURE (QCfamily
, Qlocal
);
7453 ADD_SUBFEATURE (QCfamily
, Qipv4
);
7455 ADD_SUBFEATURE (QCfamily
, Qipv6
);
7457 #ifdef HAVE_GETSOCKNAME
7458 ADD_SUBFEATURE (QCservice
, Qt
);
7460 #if defined (O_NONBLOCK) || defined (O_NDELAY)
7461 ADD_SUBFEATURE (QCserver
, Qt
);
7464 for (sopt
= socket_options
; sopt
->name
; sopt
++)
7465 subfeatures
= pure_cons (intern_c_string (sopt
->name
), subfeatures
);
7467 Fprovide (intern_c_string ("make-network-process"), subfeatures
);
7470 #if defined (DARWIN_OS)
7471 /* PTYs are broken on Darwin < 6, but are sometimes useful for interactive
7472 processes. As such, we only change the default value. */
7475 char const *release
= (STRINGP (Voperating_system_release
)
7476 ? SSDATA (Voperating_system_release
)
7478 if (!release
|| !release
[0] || (release
[0] < '7' && release
[1] == '.')) {
7479 Vprocess_connection_type
= Qnil
;
7483 #endif /* subprocesses */
7488 syms_of_process (void)
7492 DEFSYM (Qprocessp
, "processp");
7493 DEFSYM (Qrun
, "run");
7494 DEFSYM (Qstop
, "stop");
7495 DEFSYM (Qsignal
, "signal");
7497 /* Qexit is already staticpro'd by syms_of_eval; don't staticpro it
7500 Qexit = intern_c_string ("exit");
7501 staticpro (&Qexit); */
7503 DEFSYM (Qopen
, "open");
7504 DEFSYM (Qclosed
, "closed");
7505 DEFSYM (Qconnect
, "connect");
7506 DEFSYM (Qfailed
, "failed");
7507 DEFSYM (Qlisten
, "listen");
7508 DEFSYM (Qlocal
, "local");
7509 DEFSYM (Qipv4
, "ipv4");
7511 DEFSYM (Qipv6
, "ipv6");
7513 DEFSYM (Qdatagram
, "datagram");
7514 DEFSYM (Qseqpacket
, "seqpacket");
7516 DEFSYM (QCport
, ":port");
7517 DEFSYM (QCspeed
, ":speed");
7518 DEFSYM (QCprocess
, ":process");
7520 DEFSYM (QCbytesize
, ":bytesize");
7521 DEFSYM (QCstopbits
, ":stopbits");
7522 DEFSYM (QCparity
, ":parity");
7523 DEFSYM (Qodd
, "odd");
7524 DEFSYM (Qeven
, "even");
7525 DEFSYM (QCflowcontrol
, ":flowcontrol");
7528 DEFSYM (QCsummary
, ":summary");
7530 DEFSYM (Qreal
, "real");
7531 DEFSYM (Qnetwork
, "network");
7532 DEFSYM (Qserial
, "serial");
7533 DEFSYM (QCbuffer
, ":buffer");
7534 DEFSYM (QChost
, ":host");
7535 DEFSYM (QCservice
, ":service");
7536 DEFSYM (QClocal
, ":local");
7537 DEFSYM (QCremote
, ":remote");
7538 DEFSYM (QCcoding
, ":coding");
7539 DEFSYM (QCserver
, ":server");
7540 DEFSYM (QCnowait
, ":nowait");
7541 DEFSYM (QCsentinel
, ":sentinel");
7542 DEFSYM (QClog
, ":log");
7543 DEFSYM (QCnoquery
, ":noquery");
7544 DEFSYM (QCstop
, ":stop");
7545 DEFSYM (QCoptions
, ":options");
7546 DEFSYM (QCplist
, ":plist");
7548 DEFSYM (Qlast_nonmenu_event
, "last-nonmenu-event");
7550 staticpro (&Vprocess_alist
);
7552 staticpro (&deleted_pid_list
);
7555 #endif /* subprocesses */
7557 DEFSYM (QCname
, ":name");
7558 DEFSYM (QCtype
, ":type");
7560 DEFSYM (Qeuid
, "euid");
7561 DEFSYM (Qegid
, "egid");
7562 DEFSYM (Quser
, "user");
7563 DEFSYM (Qgroup
, "group");
7564 DEFSYM (Qcomm
, "comm");
7565 DEFSYM (Qstate
, "state");
7566 DEFSYM (Qppid
, "ppid");
7567 DEFSYM (Qpgrp
, "pgrp");
7568 DEFSYM (Qsess
, "sess");
7569 DEFSYM (Qttname
, "ttname");
7570 DEFSYM (Qtpgid
, "tpgid");
7571 DEFSYM (Qminflt
, "minflt");
7572 DEFSYM (Qmajflt
, "majflt");
7573 DEFSYM (Qcminflt
, "cminflt");
7574 DEFSYM (Qcmajflt
, "cmajflt");
7575 DEFSYM (Qutime
, "utime");
7576 DEFSYM (Qstime
, "stime");
7577 DEFSYM (Qtime
, "time");
7578 DEFSYM (Qcutime
, "cutime");
7579 DEFSYM (Qcstime
, "cstime");
7580 DEFSYM (Qctime
, "ctime");
7581 DEFSYM (Qpri
, "pri");
7582 DEFSYM (Qnice
, "nice");
7583 DEFSYM (Qthcount
, "thcount");
7584 DEFSYM (Qstart
, "start");
7585 DEFSYM (Qvsize
, "vsize");
7586 DEFSYM (Qrss
, "rss");
7587 DEFSYM (Qetime
, "etime");
7588 DEFSYM (Qpcpu
, "pcpu");
7589 DEFSYM (Qpmem
, "pmem");
7590 DEFSYM (Qargs
, "args");
7592 DEFVAR_BOOL ("delete-exited-processes", delete_exited_processes
,
7593 doc
: /* Non-nil means delete processes immediately when they exit.
7594 A value of nil means don't delete them until `list-processes' is run. */);
7596 delete_exited_processes
= 1;
7599 DEFVAR_LISP ("process-connection-type", Vprocess_connection_type
,
7600 doc
: /* Control type of device used to communicate with subprocesses.
7601 Values are nil to use a pipe, or t or `pty' to use a pty.
7602 The value has no effect if the system has no ptys or if all ptys are busy:
7603 then a pipe is used in any case.
7604 The value takes effect when `start-process' is called. */);
7605 Vprocess_connection_type
= Qt
;
7607 #ifdef ADAPTIVE_READ_BUFFERING
7608 DEFVAR_LISP ("process-adaptive-read-buffering", Vprocess_adaptive_read_buffering
,
7609 doc
: /* If non-nil, improve receive buffering by delaying after short reads.
7610 On some systems, when Emacs reads the output from a subprocess, the output data
7611 is read in very small blocks, potentially resulting in very poor performance.
7612 This behavior can be remedied to some extent by setting this variable to a
7613 non-nil value, as it will automatically delay reading from such processes, to
7614 allow them to produce more output before Emacs tries to read it.
7615 If the value is t, the delay is reset after each write to the process; any other
7616 non-nil value means that the delay is not reset on write.
7617 The variable takes effect when `start-process' is called. */);
7618 Vprocess_adaptive_read_buffering
= Qt
;
7621 defsubr (&Sprocessp
);
7622 defsubr (&Sget_process
);
7623 defsubr (&Sdelete_process
);
7624 defsubr (&Sprocess_status
);
7625 defsubr (&Sprocess_exit_status
);
7626 defsubr (&Sprocess_id
);
7627 defsubr (&Sprocess_name
);
7628 defsubr (&Sprocess_tty_name
);
7629 defsubr (&Sprocess_command
);
7630 defsubr (&Sset_process_buffer
);
7631 defsubr (&Sprocess_buffer
);
7632 defsubr (&Sprocess_mark
);
7633 defsubr (&Sset_process_filter
);
7634 defsubr (&Sprocess_filter
);
7635 defsubr (&Sset_process_sentinel
);
7636 defsubr (&Sprocess_sentinel
);
7637 defsubr (&Sset_process_window_size
);
7638 defsubr (&Sset_process_inherit_coding_system_flag
);
7639 defsubr (&Sset_process_query_on_exit_flag
);
7640 defsubr (&Sprocess_query_on_exit_flag
);
7641 defsubr (&Sprocess_contact
);
7642 defsubr (&Sprocess_plist
);
7643 defsubr (&Sset_process_plist
);
7644 defsubr (&Sprocess_list
);
7645 defsubr (&Sstart_process
);
7646 defsubr (&Sserial_process_configure
);
7647 defsubr (&Smake_serial_process
);
7648 defsubr (&Sset_network_process_option
);
7649 defsubr (&Smake_network_process
);
7650 defsubr (&Sformat_network_address
);
7651 #if defined (HAVE_NET_IF_H)
7653 defsubr (&Snetwork_interface_list
);
7655 #if defined (SIOCGIFADDR) || defined (SIOCGIFHWADDR) || defined (SIOCGIFFLAGS)
7656 defsubr (&Snetwork_interface_info
);
7658 #endif /* defined (HAVE_NET_IF_H) */
7659 #ifdef DATAGRAM_SOCKETS
7660 defsubr (&Sprocess_datagram_address
);
7661 defsubr (&Sset_process_datagram_address
);
7663 defsubr (&Saccept_process_output
);
7664 defsubr (&Sprocess_send_region
);
7665 defsubr (&Sprocess_send_string
);
7666 defsubr (&Sinterrupt_process
);
7667 defsubr (&Skill_process
);
7668 defsubr (&Squit_process
);
7669 defsubr (&Sstop_process
);
7670 defsubr (&Scontinue_process
);
7671 defsubr (&Sprocess_running_child_p
);
7672 defsubr (&Sprocess_send_eof
);
7673 defsubr (&Ssignal_process
);
7674 defsubr (&Swaiting_for_user_input_p
);
7675 defsubr (&Sprocess_type
);
7676 defsubr (&Sset_process_coding_system
);
7677 defsubr (&Sprocess_coding_system
);
7678 defsubr (&Sset_process_filter_multibyte
);
7679 defsubr (&Sprocess_filter_multibyte_p
);
7681 #endif /* subprocesses */
7683 defsubr (&Sget_buffer_process
);
7684 defsubr (&Sprocess_inherit_coding_system_flag
);
7685 defsubr (&Slist_system_processes
);
7686 defsubr (&Sprocess_attributes
);