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
28 #include <sys/types.h> /* Some typedefs are used in sys/file.h. */
36 /* Only MS-DOS does not define `subprocesses'. */
39 #include <sys/socket.h>
41 #include <netinet/in.h>
42 #include <arpa/inet.h>
44 /* Are local (unix) sockets supported? */
45 #if defined (HAVE_SYS_UN_H)
46 #if !defined (AF_LOCAL) && defined (AF_UNIX)
47 #define AF_LOCAL AF_UNIX
50 #define HAVE_LOCAL_SOCKETS
55 #include <sys/ioctl.h>
56 #if defined (HAVE_NET_IF_H)
58 #endif /* HAVE_NET_IF_H */
60 #if defined (HAVE_IFADDRS_H)
61 /* Must be after net/if.h */
64 /* We only use structs from this header when we use getifaddrs. */
65 #if defined (HAVE_NET_IF_DL_H)
66 #include <net/if_dl.h>
76 # include <sys/stream.h>
77 # include <sys/stropts.h>
81 #include <netinet/in.h>
82 #include <arpa/nameser.h>
94 #endif /* subprocesses */
100 #include "character.h"
105 #include "termhooks.h"
106 #include "termopts.h"
107 #include "commands.h"
108 #include "keyboard.h"
109 #include "blockinput.h"
110 #include "dispextern.h"
111 #include "composite.h"
113 #include "sysselect.h"
114 #include "syssignal.h"
120 #ifdef HAVE_WINDOW_SYSTEM
122 #endif /* HAVE_WINDOW_SYSTEM */
124 #if defined (USE_GTK) || defined (HAVE_GCONF) || defined (HAVE_GSETTINGS)
125 #include "xgselect.h"
129 extern int sys_select (int, SELECT_TYPE
*, SELECT_TYPE
*, SELECT_TYPE
*,
130 EMACS_TIME
*, void *);
133 /* Work around GCC 4.7.0 bug with strict overflow checking; see
134 <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=52904>.
135 These lines can be removed once the GCC bug is fixed. */
136 #if (__GNUC__ == 4 && 3 <= __GNUC_MINOR__) || 4 < __GNUC__
137 # pragma GCC diagnostic ignored "-Wstrict-overflow"
140 Lisp_Object Qeuid
, Qegid
, Qcomm
, Qstate
, Qppid
, Qpgrp
, Qsess
, Qttname
, Qtpgid
;
141 Lisp_Object Qminflt
, Qmajflt
, Qcminflt
, Qcmajflt
, Qutime
, Qstime
, Qcstime
;
142 Lisp_Object Qcutime
, Qpri
, Qnice
, Qthcount
, Qstart
, Qvsize
, Qrss
, Qargs
;
143 Lisp_Object Quser
, Qgroup
, Qetime
, Qpcpu
, Qpmem
, Qtime
, Qctime
;
144 Lisp_Object QCname
, QCtype
;
146 /* Non-zero if keyboard input is on hold, zero otherwise. */
148 static int kbd_is_on_hold
;
150 /* Nonzero means don't run process sentinels. This is used
152 int inhibit_sentinels
;
156 Lisp_Object Qprocessp
;
157 static Lisp_Object Qrun
, Qstop
, Qsignal
;
158 static Lisp_Object Qopen
, Qclosed
, Qconnect
, Qfailed
, Qlisten
;
160 static Lisp_Object Qipv4
, Qdatagram
, Qseqpacket
;
161 static Lisp_Object Qreal
, Qnetwork
, Qserial
;
163 static Lisp_Object Qipv6
;
165 static Lisp_Object QCport
, QCprocess
;
167 Lisp_Object QCbytesize
, QCstopbits
, QCparity
, Qodd
, Qeven
;
168 Lisp_Object QCflowcontrol
, Qhw
, Qsw
, QCsummary
;
169 static Lisp_Object QCbuffer
, QChost
, QCservice
;
170 static Lisp_Object QClocal
, QCremote
, QCcoding
;
171 static Lisp_Object QCserver
, QCnowait
, QCnoquery
, QCstop
;
172 static Lisp_Object QCsentinel
, QClog
, QCoptions
, QCplist
;
173 static Lisp_Object Qlast_nonmenu_event
;
175 #define NETCONN_P(p) (EQ (XPROCESS (p)->type, Qnetwork))
176 #define NETCONN1_P(p) (EQ (p->type, Qnetwork))
177 #define SERIALCONN_P(p) (EQ (XPROCESS (p)->type, Qserial))
178 #define SERIALCONN1_P(p) (EQ (p->type, Qserial))
184 /* Number of events of change of status of a process. */
185 static EMACS_INT process_tick
;
186 /* Number of events for which the user or sentinel has been notified. */
187 static EMACS_INT update_tick
;
189 /* Define NON_BLOCKING_CONNECT if we can support non-blocking connects. */
191 /* Only W32 has this, it really means that select can't take write mask. */
192 #ifdef BROKEN_NON_BLOCKING_CONNECT
193 #undef NON_BLOCKING_CONNECT
194 #define SELECT_CANT_DO_WRITE_MASK
196 #ifndef NON_BLOCKING_CONNECT
198 #if defined (HAVE_GETPEERNAME) || defined (GNU_LINUX)
199 #if defined (EWOULDBLOCK) || defined (EINPROGRESS)
200 #define NON_BLOCKING_CONNECT
201 #endif /* EWOULDBLOCK || EINPROGRESS */
202 #endif /* HAVE_GETPEERNAME || GNU_LINUX */
203 #endif /* HAVE_SELECT */
204 #endif /* NON_BLOCKING_CONNECT */
205 #endif /* BROKEN_NON_BLOCKING_CONNECT */
207 /* Define DATAGRAM_SOCKETS if datagrams can be used safely on
208 this system. We need to read full packets, so we need a
209 "non-destructive" select. So we require either native select,
210 or emulation of select using FIONREAD. */
212 #ifndef BROKEN_DATAGRAM_SOCKETS
213 # if defined HAVE_SELECT || defined USABLE_FIONREAD
214 # if defined HAVE_SENDTO && defined HAVE_RECVFROM && defined EMSGSIZE
215 # define DATAGRAM_SOCKETS
220 #if defined HAVE_LOCAL_SOCKETS && defined DATAGRAM_SOCKETS
221 # define HAVE_SEQPACKET
224 #if !defined (ADAPTIVE_READ_BUFFERING) && !defined (NO_ADAPTIVE_READ_BUFFERING)
225 #define ADAPTIVE_READ_BUFFERING
228 #ifdef ADAPTIVE_READ_BUFFERING
229 #define READ_OUTPUT_DELAY_INCREMENT (EMACS_TIME_RESOLUTION / 100)
230 #define READ_OUTPUT_DELAY_MAX (READ_OUTPUT_DELAY_INCREMENT * 5)
231 #define READ_OUTPUT_DELAY_MAX_MAX (READ_OUTPUT_DELAY_INCREMENT * 7)
233 /* Number of processes which have a non-zero read_output_delay,
234 and therefore might be delayed for adaptive read buffering. */
236 static int process_output_delay_count
;
238 /* Non-zero if any process has non-nil read_output_skip. */
240 static int process_output_skip
;
243 #define process_output_delay_count 0
246 static void create_process (Lisp_Object
, char **, Lisp_Object
);
248 static int keyboard_bit_set (SELECT_TYPE
*);
250 static void deactivate_process (Lisp_Object
);
251 static void status_notify (struct Lisp_Process
*);
252 static int read_process_output (Lisp_Object
, int);
253 static void handle_child_signal (int);
254 static void create_pty (Lisp_Object
);
256 /* If we support a window system, turn on the code to poll periodically
257 to detect C-g. It isn't actually used when doing interrupt input. */
258 #ifdef HAVE_WINDOW_SYSTEM
259 #define POLL_FOR_INPUT
262 static Lisp_Object
get_process (register Lisp_Object name
);
263 static void exec_sentinel (Lisp_Object proc
, Lisp_Object reason
);
265 /* Mask of bits indicating the descriptors that we wait for input on. */
267 static SELECT_TYPE input_wait_mask
;
269 /* Mask that excludes keyboard input descriptor(s). */
271 static SELECT_TYPE non_keyboard_wait_mask
;
273 /* Mask that excludes process input descriptor(s). */
275 static SELECT_TYPE non_process_wait_mask
;
277 /* Mask for selecting for write. */
279 static SELECT_TYPE write_mask
;
281 #ifdef NON_BLOCKING_CONNECT
282 /* Mask of bits indicating the descriptors that we wait for connect to
283 complete on. Once they complete, they are removed from this mask
284 and added to the input_wait_mask and non_keyboard_wait_mask. */
286 static SELECT_TYPE connect_wait_mask
;
288 /* Number of bits set in connect_wait_mask. */
289 static int num_pending_connects
;
290 #endif /* NON_BLOCKING_CONNECT */
292 /* The largest descriptor currently in use for a process object. */
293 static int max_process_desc
;
295 /* The largest descriptor currently in use for input. */
296 static int max_input_desc
;
298 /* Indexed by descriptor, gives the process (if any) for that descriptor */
299 static Lisp_Object chan_process
[MAXDESC
];
301 /* Alist of elements (NAME . PROCESS) */
302 static Lisp_Object Vprocess_alist
;
304 /* Buffered-ahead input char from process, indexed by channel.
305 -1 means empty (no char is buffered).
306 Used on sys V where the only way to tell if there is any
307 output from the process is to read at least one char.
308 Always -1 on systems that support FIONREAD. */
310 static int proc_buffered_char
[MAXDESC
];
312 /* Table of `struct coding-system' for each process. */
313 static struct coding_system
*proc_decode_coding_system
[MAXDESC
];
314 static struct coding_system
*proc_encode_coding_system
[MAXDESC
];
316 #ifdef DATAGRAM_SOCKETS
317 /* Table of `partner address' for datagram sockets. */
318 static struct sockaddr_and_len
{
321 } datagram_address
[MAXDESC
];
322 #define DATAGRAM_CHAN_P(chan) (datagram_address[chan].sa != 0)
323 #define DATAGRAM_CONN_P(proc) (PROCESSP (proc) && datagram_address[XPROCESS (proc)->infd].sa != 0)
325 #define DATAGRAM_CHAN_P(chan) (0)
326 #define DATAGRAM_CONN_P(proc) (0)
329 /* These setters are used only in this file, so they can be private. */
331 pset_buffer (struct Lisp_Process
*p
, Lisp_Object val
)
336 pset_command (struct Lisp_Process
*p
, Lisp_Object val
)
341 pset_decode_coding_system (struct Lisp_Process
*p
, Lisp_Object val
)
343 p
->decode_coding_system
= val
;
346 pset_decoding_buf (struct Lisp_Process
*p
, Lisp_Object val
)
348 p
->decoding_buf
= val
;
351 pset_encode_coding_system (struct Lisp_Process
*p
, Lisp_Object val
)
353 p
->encode_coding_system
= val
;
356 pset_encoding_buf (struct Lisp_Process
*p
, Lisp_Object val
)
358 p
->encoding_buf
= val
;
361 pset_filter (struct Lisp_Process
*p
, Lisp_Object val
)
366 pset_log (struct Lisp_Process
*p
, Lisp_Object val
)
371 pset_mark (struct Lisp_Process
*p
, Lisp_Object val
)
376 pset_name (struct Lisp_Process
*p
, Lisp_Object val
)
381 pset_plist (struct Lisp_Process
*p
, Lisp_Object val
)
386 pset_sentinel (struct Lisp_Process
*p
, Lisp_Object val
)
391 pset_status (struct Lisp_Process
*p
, Lisp_Object val
)
396 pset_tty_name (struct Lisp_Process
*p
, Lisp_Object val
)
401 pset_type (struct Lisp_Process
*p
, Lisp_Object val
)
406 pset_write_queue (struct Lisp_Process
*p
, Lisp_Object val
)
408 p
->write_queue
= val
;
413 static struct fd_callback_data
419 int condition
; /* mask of the defines above. */
420 } fd_callback_info
[MAXDESC
];
423 /* Add a file descriptor FD to be monitored for when read is possible.
424 When read is possible, call FUNC with argument DATA. */
427 add_read_fd (int fd
, fd_callback func
, void *data
)
429 eassert (fd
< MAXDESC
);
430 add_keyboard_wait_descriptor (fd
);
432 fd_callback_info
[fd
].func
= func
;
433 fd_callback_info
[fd
].data
= data
;
434 fd_callback_info
[fd
].condition
|= FOR_READ
;
437 /* Stop monitoring file descriptor FD for when read is possible. */
440 delete_read_fd (int fd
)
442 eassert (fd
< MAXDESC
);
443 delete_keyboard_wait_descriptor (fd
);
445 fd_callback_info
[fd
].condition
&= ~FOR_READ
;
446 if (fd_callback_info
[fd
].condition
== 0)
448 fd_callback_info
[fd
].func
= 0;
449 fd_callback_info
[fd
].data
= 0;
453 /* Add a file descriptor FD to be monitored for when write is possible.
454 When write is possible, call FUNC with argument DATA. */
457 add_write_fd (int fd
, fd_callback func
, void *data
)
459 eassert (fd
< MAXDESC
);
460 FD_SET (fd
, &write_mask
);
461 if (fd
> max_input_desc
)
464 fd_callback_info
[fd
].func
= func
;
465 fd_callback_info
[fd
].data
= data
;
466 fd_callback_info
[fd
].condition
|= FOR_WRITE
;
469 /* Stop monitoring file descriptor FD for when write is possible. */
472 delete_write_fd (int fd
)
474 int lim
= max_input_desc
;
476 eassert (fd
< MAXDESC
);
477 FD_CLR (fd
, &write_mask
);
478 fd_callback_info
[fd
].condition
&= ~FOR_WRITE
;
479 if (fd_callback_info
[fd
].condition
== 0)
481 fd_callback_info
[fd
].func
= 0;
482 fd_callback_info
[fd
].data
= 0;
484 if (fd
== max_input_desc
)
485 for (fd
= lim
; fd
>= 0; fd
--)
486 if (FD_ISSET (fd
, &input_wait_mask
) || FD_ISSET (fd
, &write_mask
))
496 /* Compute the Lisp form of the process status, p->status, from
497 the numeric status that was returned by `wait'. */
499 static Lisp_Object
status_convert (int);
502 update_status (struct Lisp_Process
*p
)
504 eassert (p
->raw_status_new
);
505 pset_status (p
, status_convert (p
->raw_status
));
506 p
->raw_status_new
= 0;
509 /* Convert a process status word in Unix format to
510 the list that we use internally. */
513 status_convert (int w
)
516 return Fcons (Qstop
, Fcons (make_number (WSTOPSIG (w
)), Qnil
));
517 else if (WIFEXITED (w
))
518 return Fcons (Qexit
, Fcons (make_number (WEXITSTATUS (w
)),
519 WCOREDUMP (w
) ? Qt
: Qnil
));
520 else if (WIFSIGNALED (w
))
521 return Fcons (Qsignal
, Fcons (make_number (WTERMSIG (w
)),
522 WCOREDUMP (w
) ? Qt
: Qnil
));
527 /* Given a status-list, extract the three pieces of information
528 and store them individually through the three pointers. */
531 decode_status (Lisp_Object l
, Lisp_Object
*symbol
, int *code
, int *coredump
)
545 *code
= XFASTINT (XCAR (tem
));
547 *coredump
= !NILP (tem
);
551 /* Return a string describing a process status list. */
554 status_message (struct Lisp_Process
*p
)
556 Lisp_Object status
= p
->status
;
559 Lisp_Object string
, string2
;
561 decode_status (status
, &symbol
, &code
, &coredump
);
563 if (EQ (symbol
, Qsignal
) || EQ (symbol
, Qstop
))
566 synchronize_system_messages_locale ();
567 signame
= strsignal (code
);
569 string
= build_string ("unknown");
574 string
= build_unibyte_string (signame
);
575 if (! NILP (Vlocale_coding_system
))
576 string
= (code_convert_string_norecord
577 (string
, Vlocale_coding_system
, 0));
578 c1
= STRING_CHAR (SDATA (string
));
581 Faset (string
, make_number (0), make_number (c2
));
583 string2
= build_string (coredump
? " (core dumped)\n" : "\n");
584 return concat2 (string
, string2
);
586 else if (EQ (symbol
, Qexit
))
589 return build_string (code
== 0 ? "deleted\n" : "connection broken by remote peer\n");
591 return build_string ("finished\n");
592 string
= Fnumber_to_string (make_number (code
));
593 string2
= build_string (coredump
? " (core dumped)\n" : "\n");
594 return concat3 (build_string ("exited abnormally with code "),
597 else if (EQ (symbol
, Qfailed
))
599 string
= Fnumber_to_string (make_number (code
));
600 string2
= build_string ("\n");
601 return concat3 (build_string ("failed with code "),
605 return Fcopy_sequence (Fsymbol_name (symbol
));
610 /* The file name of the pty opened by allocate_pty. */
611 static char pty_name
[24];
613 /* Open an available pty, returning a file descriptor.
614 Return -1 on failure.
615 The file name of the terminal corresponding to the pty
616 is left in the variable pty_name. */
627 for (c
= FIRST_PTY_LETTER
; c
<= 'z'; c
++)
628 for (i
= 0; i
< 16; i
++)
631 #ifdef PTY_NAME_SPRINTF
634 sprintf (pty_name
, "/dev/pty%c%x", c
, i
);
635 #endif /* no PTY_NAME_SPRINTF */
639 #else /* no PTY_OPEN */
640 fd
= emacs_open (pty_name
, O_RDWR
| O_NONBLOCK
, 0);
641 #endif /* no PTY_OPEN */
645 /* check to make certain that both sides are available
646 this avoids a nasty yet stupid bug in rlogins */
647 #ifdef PTY_TTY_NAME_SPRINTF
650 sprintf (pty_name
, "/dev/tty%c%x", c
, i
);
651 #endif /* no PTY_TTY_NAME_SPRINTF */
652 if (faccessat (AT_FDCWD
, pty_name
, R_OK
| W_OK
, AT_EACCESS
) != 0)
667 #endif /* HAVE_PTYS */
670 make_process (Lisp_Object name
)
672 register Lisp_Object val
, tem
, name1
;
673 register struct Lisp_Process
*p
;
674 char suffix
[sizeof "<>" + INT_STRLEN_BOUND (printmax_t
)];
677 p
= allocate_process ();
678 /* Initialize Lisp data. Note that allocate_process initializes all
679 Lisp data to nil, so do it only for slots which should not be nil. */
680 pset_status (p
, Qrun
);
681 pset_mark (p
, Fmake_marker ());
683 /* Initialize non-Lisp data. Note that allocate_process zeroes out all
684 non-Lisp data, so do it only for slots which should not be zero. */
689 p
->gnutls_initstage
= GNUTLS_STAGE_EMPTY
;
692 /* If name is already in use, modify it until it is unused. */
697 tem
= Fget_process (name1
);
698 if (NILP (tem
)) break;
699 name1
= concat2 (name
, make_formatted_string (suffix
, "<%"pMd
">", i
));
703 XSETPROCESS (val
, p
);
704 Vprocess_alist
= Fcons (Fcons (name
, val
), Vprocess_alist
);
709 remove_process (register Lisp_Object proc
)
711 register Lisp_Object pair
;
713 pair
= Frassq (proc
, Vprocess_alist
);
714 Vprocess_alist
= Fdelq (pair
, Vprocess_alist
);
716 deactivate_process (proc
);
720 DEFUN ("processp", Fprocessp
, Sprocessp
, 1, 1, 0,
721 doc
: /* Return t if OBJECT is a process. */)
724 return PROCESSP (object
) ? Qt
: Qnil
;
727 DEFUN ("get-process", Fget_process
, Sget_process
, 1, 1, 0,
728 doc
: /* Return the process named NAME, or nil if there is none. */)
729 (register Lisp_Object name
)
734 return Fcdr (Fassoc (name
, Vprocess_alist
));
737 /* This is how commands for the user decode process arguments. It
738 accepts a process, a process name, a buffer, a buffer name, or nil.
739 Buffers denote the first process in the buffer, and nil denotes the
743 get_process (register Lisp_Object name
)
745 register Lisp_Object proc
, obj
;
748 obj
= Fget_process (name
);
750 obj
= Fget_buffer (name
);
752 error ("Process %s does not exist", SDATA (name
));
754 else if (NILP (name
))
755 obj
= Fcurrent_buffer ();
759 /* Now obj should be either a buffer object or a process object.
763 proc
= Fget_buffer_process (obj
);
765 error ("Buffer %s has no process", SDATA (BVAR (XBUFFER (obj
), name
)));
777 /* Fdelete_process promises to immediately forget about the process, but in
778 reality, Emacs needs to remember those processes until they have been
779 treated by the SIGCHLD handler and waitpid has been invoked on them;
780 otherwise they might fill up the kernel's process table.
782 Some processes created by call-process are also put onto this list. */
783 static Lisp_Object deleted_pid_list
;
787 record_deleted_pid (pid_t pid
)
790 deleted_pid_list
= Fcons (make_fixnum_or_float (pid
),
791 /* GC treated elements set to nil. */
792 Fdelq (Qnil
, deleted_pid_list
));
797 DEFUN ("delete-process", Fdelete_process
, Sdelete_process
, 1, 1, 0,
798 doc
: /* Delete PROCESS: kill it and forget about it immediately.
799 PROCESS may be a process, a buffer, the name of a process or buffer, or
800 nil, indicating the current buffer's process. */)
801 (register Lisp_Object process
)
803 register struct Lisp_Process
*p
;
805 process
= get_process (process
);
806 p
= XPROCESS (process
);
808 p
->raw_status_new
= 0;
809 if (NETCONN1_P (p
) || SERIALCONN1_P (p
))
811 pset_status (p
, Fcons (Qexit
, Fcons (make_number (0), Qnil
)));
812 p
->tick
= ++process_tick
;
814 redisplay_preserve_echo_area (13);
819 record_kill_process (p
);
823 /* Update P's status, since record_kill_process will make the
824 SIGCHLD handler update deleted_pid_list, not *P. */
826 if (p
->raw_status_new
)
828 symbol
= CONSP (p
->status
) ? XCAR (p
->status
) : p
->status
;
829 if (! (EQ (symbol
, Qsignal
) || EQ (symbol
, Qexit
)))
830 pset_status (p
, list2 (Qsignal
, make_number (SIGKILL
)));
832 p
->tick
= ++process_tick
;
834 redisplay_preserve_echo_area (13);
837 remove_process (process
);
841 DEFUN ("process-status", Fprocess_status
, Sprocess_status
, 1, 1, 0,
842 doc
: /* Return the status of PROCESS.
843 The returned value is one of the following symbols:
844 run -- for a process that is running.
845 stop -- for a process stopped but continuable.
846 exit -- for a process that has exited.
847 signal -- for a process that has got a fatal signal.
848 open -- for a network stream connection that is open.
849 listen -- for a network stream server that is listening.
850 closed -- for a network stream connection that is closed.
851 connect -- when waiting for a non-blocking connection to complete.
852 failed -- when a non-blocking connection has failed.
853 nil -- if arg is a process name and no such process exists.
854 PROCESS may be a process, a buffer, the name of a process, or
855 nil, indicating the current buffer's process. */)
856 (register Lisp_Object process
)
858 register struct Lisp_Process
*p
;
859 register Lisp_Object status
;
861 if (STRINGP (process
))
862 process
= Fget_process (process
);
864 process
= get_process (process
);
869 p
= XPROCESS (process
);
870 if (p
->raw_status_new
)
874 status
= XCAR (status
);
875 if (NETCONN1_P (p
) || SERIALCONN1_P (p
))
877 if (EQ (status
, Qexit
))
879 else if (EQ (p
->command
, Qt
))
881 else if (EQ (status
, Qrun
))
887 DEFUN ("process-exit-status", Fprocess_exit_status
, Sprocess_exit_status
,
889 doc
: /* Return the exit status of PROCESS or the signal number that killed it.
890 If PROCESS has not yet exited or died, return 0. */)
891 (register Lisp_Object process
)
893 CHECK_PROCESS (process
);
894 if (XPROCESS (process
)->raw_status_new
)
895 update_status (XPROCESS (process
));
896 if (CONSP (XPROCESS (process
)->status
))
897 return XCAR (XCDR (XPROCESS (process
)->status
));
898 return make_number (0);
901 DEFUN ("process-id", Fprocess_id
, Sprocess_id
, 1, 1, 0,
902 doc
: /* Return the process id of PROCESS.
903 This is the pid of the external process which PROCESS uses or talks to.
904 For a network connection, this value is nil. */)
905 (register Lisp_Object process
)
909 CHECK_PROCESS (process
);
910 pid
= XPROCESS (process
)->pid
;
911 return (pid
? make_fixnum_or_float (pid
) : Qnil
);
914 DEFUN ("process-name", Fprocess_name
, Sprocess_name
, 1, 1, 0,
915 doc
: /* Return the name of PROCESS, as a string.
916 This is the name of the program invoked in PROCESS,
917 possibly modified to make it unique among process names. */)
918 (register Lisp_Object process
)
920 CHECK_PROCESS (process
);
921 return XPROCESS (process
)->name
;
924 DEFUN ("process-command", Fprocess_command
, Sprocess_command
, 1, 1, 0,
925 doc
: /* Return the command that was executed to start PROCESS.
926 This is a list of strings, the first string being the program executed
927 and the rest of the strings being the arguments given to it.
928 For a network or serial process, this is nil (process is running) or t
929 \(process is stopped). */)
930 (register Lisp_Object process
)
932 CHECK_PROCESS (process
);
933 return XPROCESS (process
)->command
;
936 DEFUN ("process-tty-name", Fprocess_tty_name
, Sprocess_tty_name
, 1, 1, 0,
937 doc
: /* Return the name of the terminal PROCESS uses, or nil if none.
938 This is the terminal that the process itself reads and writes on,
939 not the name of the pty that Emacs uses to talk with that terminal. */)
940 (register Lisp_Object process
)
942 CHECK_PROCESS (process
);
943 return XPROCESS (process
)->tty_name
;
946 DEFUN ("set-process-buffer", Fset_process_buffer
, Sset_process_buffer
,
948 doc
: /* Set buffer associated with PROCESS to BUFFER (a buffer, or nil).
950 (register Lisp_Object process
, Lisp_Object buffer
)
952 struct Lisp_Process
*p
;
954 CHECK_PROCESS (process
);
956 CHECK_BUFFER (buffer
);
957 p
= XPROCESS (process
);
958 pset_buffer (p
, buffer
);
959 if (NETCONN1_P (p
) || SERIALCONN1_P (p
))
960 pset_childp (p
, Fplist_put (p
->childp
, QCbuffer
, buffer
));
961 setup_process_coding_systems (process
);
965 DEFUN ("process-buffer", Fprocess_buffer
, Sprocess_buffer
,
967 doc
: /* Return the buffer PROCESS is associated with.
968 Output from PROCESS is inserted in this buffer unless PROCESS has a filter. */)
969 (register Lisp_Object process
)
971 CHECK_PROCESS (process
);
972 return XPROCESS (process
)->buffer
;
975 DEFUN ("process-mark", Fprocess_mark
, Sprocess_mark
,
977 doc
: /* Return the marker for the end of the last output from PROCESS. */)
978 (register Lisp_Object process
)
980 CHECK_PROCESS (process
);
981 return XPROCESS (process
)->mark
;
984 DEFUN ("set-process-filter", Fset_process_filter
, Sset_process_filter
,
986 doc
: /* Give PROCESS the filter function FILTER; nil means no filter.
987 A value of t means stop accepting output from the process.
989 When a process has a filter, its buffer is not used for output.
990 Instead, each time it does output, the entire string of output is
991 passed to the filter.
993 The filter gets two arguments: the process and the string of output.
994 The string argument is normally a multibyte string, except:
995 - if the process' input coding system is no-conversion or raw-text,
996 it is a unibyte string (the non-converted input), or else
997 - if `default-enable-multibyte-characters' is nil, it is a unibyte
998 string (the result of converting the decoded input multibyte
999 string to unibyte with `string-make-unibyte'). */)
1000 (register Lisp_Object process
, Lisp_Object filter
)
1002 struct Lisp_Process
*p
;
1004 CHECK_PROCESS (process
);
1005 p
= XPROCESS (process
);
1007 /* Don't signal an error if the process' input file descriptor
1008 is closed. This could make debugging Lisp more difficult,
1009 for example when doing something like
1011 (setq process (start-process ...))
1013 (set-process-filter process ...) */
1017 if (EQ (filter
, Qt
) && !EQ (p
->status
, Qlisten
))
1019 FD_CLR (p
->infd
, &input_wait_mask
);
1020 FD_CLR (p
->infd
, &non_keyboard_wait_mask
);
1022 else if (EQ (p
->filter
, Qt
)
1023 /* Network or serial process not stopped: */
1024 && !EQ (p
->command
, Qt
))
1026 FD_SET (p
->infd
, &input_wait_mask
);
1027 FD_SET (p
->infd
, &non_keyboard_wait_mask
);
1031 pset_filter (p
, filter
);
1032 if (NETCONN1_P (p
) || SERIALCONN1_P (p
))
1033 pset_childp (p
, Fplist_put (p
->childp
, QCfilter
, filter
));
1034 setup_process_coding_systems (process
);
1038 DEFUN ("process-filter", Fprocess_filter
, Sprocess_filter
,
1040 doc
: /* Returns the filter function of PROCESS; nil if none.
1041 See `set-process-filter' for more info on filter functions. */)
1042 (register Lisp_Object process
)
1044 CHECK_PROCESS (process
);
1045 return XPROCESS (process
)->filter
;
1048 DEFUN ("set-process-sentinel", Fset_process_sentinel
, Sset_process_sentinel
,
1050 doc
: /* Give PROCESS the sentinel SENTINEL; nil for none.
1051 The sentinel is called as a function when the process changes state.
1052 It gets two arguments: the process, and a string describing the change. */)
1053 (register Lisp_Object process
, Lisp_Object sentinel
)
1055 struct Lisp_Process
*p
;
1057 CHECK_PROCESS (process
);
1058 p
= XPROCESS (process
);
1060 pset_sentinel (p
, sentinel
);
1061 if (NETCONN1_P (p
) || SERIALCONN1_P (p
))
1062 pset_childp (p
, Fplist_put (p
->childp
, QCsentinel
, sentinel
));
1066 DEFUN ("process-sentinel", Fprocess_sentinel
, Sprocess_sentinel
,
1068 doc
: /* Return the sentinel of PROCESS; nil if none.
1069 See `set-process-sentinel' for more info on sentinels. */)
1070 (register Lisp_Object process
)
1072 CHECK_PROCESS (process
);
1073 return XPROCESS (process
)->sentinel
;
1076 DEFUN ("set-process-window-size", Fset_process_window_size
,
1077 Sset_process_window_size
, 3, 3, 0,
1078 doc
: /* Tell PROCESS that it has logical window size HEIGHT and WIDTH. */)
1079 (register Lisp_Object process
, Lisp_Object height
, Lisp_Object width
)
1081 CHECK_PROCESS (process
);
1082 CHECK_RANGED_INTEGER (height
, 0, INT_MAX
);
1083 CHECK_RANGED_INTEGER (width
, 0, INT_MAX
);
1085 if (XPROCESS (process
)->infd
< 0
1086 || set_window_size (XPROCESS (process
)->infd
,
1087 XINT (height
), XINT (width
)) <= 0)
1093 DEFUN ("set-process-inherit-coding-system-flag",
1094 Fset_process_inherit_coding_system_flag
,
1095 Sset_process_inherit_coding_system_flag
, 2, 2, 0,
1096 doc
: /* Determine whether buffer of PROCESS will inherit coding-system.
1097 If the second argument FLAG is non-nil, then the variable
1098 `buffer-file-coding-system' of the buffer associated with PROCESS
1099 will be bound to the value of the coding system used to decode
1102 This is useful when the coding system specified for the process buffer
1103 leaves either the character code conversion or the end-of-line conversion
1104 unspecified, or if the coding system used to decode the process output
1105 is more appropriate for saving the process buffer.
1107 Binding the variable `inherit-process-coding-system' to non-nil before
1108 starting the process is an alternative way of setting the inherit flag
1109 for the process which will run.
1111 This function returns FLAG. */)
1112 (register Lisp_Object process
, Lisp_Object flag
)
1114 CHECK_PROCESS (process
);
1115 XPROCESS (process
)->inherit_coding_system_flag
= !NILP (flag
);
1119 DEFUN ("set-process-query-on-exit-flag",
1120 Fset_process_query_on_exit_flag
, Sset_process_query_on_exit_flag
,
1122 doc
: /* Specify if query is needed for PROCESS when Emacs is exited.
1123 If the second argument FLAG is non-nil, Emacs will query the user before
1124 exiting or killing a buffer if PROCESS is running. This function
1126 (register Lisp_Object process
, Lisp_Object flag
)
1128 CHECK_PROCESS (process
);
1129 XPROCESS (process
)->kill_without_query
= NILP (flag
);
1133 DEFUN ("process-query-on-exit-flag",
1134 Fprocess_query_on_exit_flag
, Sprocess_query_on_exit_flag
,
1136 doc
: /* Return the current value of query-on-exit flag for PROCESS. */)
1137 (register Lisp_Object process
)
1139 CHECK_PROCESS (process
);
1140 return (XPROCESS (process
)->kill_without_query
? Qnil
: Qt
);
1143 DEFUN ("process-contact", Fprocess_contact
, Sprocess_contact
,
1145 doc
: /* Return the contact info of PROCESS; t for a real child.
1146 For a network or serial connection, the value depends on the optional
1147 KEY arg. If KEY is nil, value is a cons cell of the form (HOST
1148 SERVICE) for a network connection or (PORT SPEED) for a serial
1149 connection. If KEY is t, the complete contact information for the
1150 connection is returned, else the specific value for the keyword KEY is
1151 returned. See `make-network-process' or `make-serial-process' for a
1152 list of keywords. */)
1153 (register Lisp_Object process
, Lisp_Object key
)
1155 Lisp_Object contact
;
1157 CHECK_PROCESS (process
);
1158 contact
= XPROCESS (process
)->childp
;
1160 #ifdef DATAGRAM_SOCKETS
1161 if (DATAGRAM_CONN_P (process
)
1162 && (EQ (key
, Qt
) || EQ (key
, QCremote
)))
1163 contact
= Fplist_put (contact
, QCremote
,
1164 Fprocess_datagram_address (process
));
1167 if ((!NETCONN_P (process
) && !SERIALCONN_P (process
)) || EQ (key
, Qt
))
1169 if (NILP (key
) && NETCONN_P (process
))
1170 return Fcons (Fplist_get (contact
, QChost
),
1171 Fcons (Fplist_get (contact
, QCservice
), Qnil
));
1172 if (NILP (key
) && SERIALCONN_P (process
))
1173 return Fcons (Fplist_get (contact
, QCport
),
1174 Fcons (Fplist_get (contact
, QCspeed
), Qnil
));
1175 return Fplist_get (contact
, key
);
1178 DEFUN ("process-plist", Fprocess_plist
, Sprocess_plist
,
1180 doc
: /* Return the plist of PROCESS. */)
1181 (register Lisp_Object process
)
1183 CHECK_PROCESS (process
);
1184 return XPROCESS (process
)->plist
;
1187 DEFUN ("set-process-plist", Fset_process_plist
, Sset_process_plist
,
1189 doc
: /* Replace the plist of PROCESS with PLIST. Returns PLIST. */)
1190 (register Lisp_Object process
, Lisp_Object plist
)
1192 CHECK_PROCESS (process
);
1195 pset_plist (XPROCESS (process
), plist
);
1199 #if 0 /* Turned off because we don't currently record this info
1200 in the process. Perhaps add it. */
1201 DEFUN ("process-connection", Fprocess_connection
, Sprocess_connection
, 1, 1, 0,
1202 doc
: /* Return the connection type of PROCESS.
1203 The value is nil for a pipe, t or `pty' for a pty, or `stream' for
1204 a socket connection. */)
1205 (Lisp_Object process
)
1207 return XPROCESS (process
)->type
;
1211 DEFUN ("process-type", Fprocess_type
, Sprocess_type
, 1, 1, 0,
1212 doc
: /* Return the connection type of PROCESS.
1213 The value is either the symbol `real', `network', or `serial'.
1214 PROCESS may be a process, a buffer, the name of a process or buffer, or
1215 nil, indicating the current buffer's process. */)
1216 (Lisp_Object process
)
1219 proc
= get_process (process
);
1220 return XPROCESS (proc
)->type
;
1223 DEFUN ("format-network-address", Fformat_network_address
, Sformat_network_address
,
1225 doc
: /* Convert network ADDRESS from internal format to a string.
1226 A 4 or 5 element vector represents an IPv4 address (with port number).
1227 An 8 or 9 element vector represents an IPv6 address (with port number).
1228 If optional second argument OMIT-PORT is non-nil, don't include a port
1229 number in the string, even when present in ADDRESS.
1230 Returns nil if format of ADDRESS is invalid. */)
1231 (Lisp_Object address
, Lisp_Object omit_port
)
1236 if (STRINGP (address
)) /* AF_LOCAL */
1239 if (VECTORP (address
)) /* AF_INET or AF_INET6 */
1241 register struct Lisp_Vector
*p
= XVECTOR (address
);
1242 ptrdiff_t size
= p
->header
.size
;
1243 Lisp_Object args
[10];
1246 if (size
== 4 || (size
== 5 && !NILP (omit_port
)))
1248 args
[0] = build_string ("%d.%d.%d.%d");
1253 args
[0] = build_string ("%d.%d.%d.%d:%d");
1256 else if (size
== 8 || (size
== 9 && !NILP (omit_port
)))
1258 args
[0] = build_string ("%x:%x:%x:%x:%x:%x:%x:%x");
1263 args
[0] = build_string ("[%x:%x:%x:%x:%x:%x:%x:%x]:%d");
1269 for (i
= 0; i
< nargs
; i
++)
1271 if (! RANGED_INTEGERP (0, p
->contents
[i
], 65535))
1274 if (nargs
<= 5 /* IPv4 */
1275 && i
< 4 /* host, not port */
1276 && XINT (p
->contents
[i
]) > 255)
1279 args
[i
+1] = p
->contents
[i
];
1282 return Fformat (nargs
+1, args
);
1285 if (CONSP (address
))
1287 Lisp_Object args
[2];
1288 args
[0] = build_string ("<Family %d>");
1289 args
[1] = Fcar (address
);
1290 return Fformat (2, args
);
1296 DEFUN ("process-list", Fprocess_list
, Sprocess_list
, 0, 0, 0,
1297 doc
: /* Return a list of all processes. */)
1300 return Fmapcar (Qcdr
, Vprocess_alist
);
1303 /* Starting asynchronous inferior processes. */
1305 static Lisp_Object
start_process_unwind (Lisp_Object proc
);
1307 DEFUN ("start-process", Fstart_process
, Sstart_process
, 3, MANY
, 0,
1308 doc
: /* Start a program in a subprocess. Return the process object for it.
1309 NAME is name for process. It is modified if necessary to make it unique.
1310 BUFFER is the buffer (or buffer name) to associate with the process.
1312 Process output (both standard output and standard error streams) goes
1313 at end of BUFFER, unless you specify an output stream or filter
1314 function to handle the output. BUFFER may also be nil, meaning that
1315 this process is not associated with any buffer.
1317 PROGRAM is the program file name. It is searched for in `exec-path'
1318 (which see). If nil, just associate a pty with the buffer. Remaining
1319 arguments are strings to give program as arguments.
1321 If you want to separate standard output from standard error, invoke
1322 the command through a shell and redirect one of them using the shell
1325 usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS) */)
1326 (ptrdiff_t nargs
, Lisp_Object
*args
)
1328 Lisp_Object buffer
, name
, program
, proc
, current_dir
, tem
;
1329 register unsigned char **new_argv
;
1331 ptrdiff_t count
= SPECPDL_INDEX ();
1335 buffer
= Fget_buffer_create (buffer
);
1337 /* Make sure that the child will be able to chdir to the current
1338 buffer's current directory, or its unhandled equivalent. We
1339 can't just have the child check for an error when it does the
1340 chdir, since it's in a vfork.
1342 We have to GCPRO around this because Fexpand_file_name and
1343 Funhandled_file_name_directory might call a file name handling
1344 function. The argument list is protected by the caller, so all
1345 we really have to worry about is buffer. */
1347 struct gcpro gcpro1
, gcpro2
;
1349 current_dir
= BVAR (current_buffer
, directory
);
1351 GCPRO2 (buffer
, current_dir
);
1353 current_dir
= Funhandled_file_name_directory (current_dir
);
1354 if (NILP (current_dir
))
1355 /* If the file name handler says that current_dir is unreachable, use
1356 a sensible default. */
1357 current_dir
= build_string ("~/");
1358 current_dir
= expand_and_dir_to_file (current_dir
, Qnil
);
1359 if (NILP (Ffile_accessible_directory_p (current_dir
)))
1360 report_file_error ("Setting current directory",
1361 Fcons (BVAR (current_buffer
, directory
), Qnil
));
1367 CHECK_STRING (name
);
1371 if (!NILP (program
))
1372 CHECK_STRING (program
);
1374 proc
= make_process (name
);
1375 /* If an error occurs and we can't start the process, we want to
1376 remove it from the process list. This means that each error
1377 check in create_process doesn't need to call remove_process
1378 itself; it's all taken care of here. */
1379 record_unwind_protect (start_process_unwind
, proc
);
1381 pset_childp (XPROCESS (proc
), Qt
);
1382 pset_plist (XPROCESS (proc
), Qnil
);
1383 pset_type (XPROCESS (proc
), Qreal
);
1384 pset_buffer (XPROCESS (proc
), buffer
);
1385 pset_sentinel (XPROCESS (proc
), Qnil
);
1386 pset_filter (XPROCESS (proc
), Qnil
);
1387 pset_command (XPROCESS (proc
), Flist (nargs
- 2, args
+ 2));
1390 /* AKA GNUTLS_INITSTAGE(proc). */
1391 XPROCESS (proc
)->gnutls_initstage
= GNUTLS_STAGE_EMPTY
;
1392 pset_gnutls_cred_type (XPROCESS (proc
), Qnil
);
1395 #ifdef ADAPTIVE_READ_BUFFERING
1396 XPROCESS (proc
)->adaptive_read_buffering
1397 = (NILP (Vprocess_adaptive_read_buffering
) ? 0
1398 : EQ (Vprocess_adaptive_read_buffering
, Qt
) ? 1 : 2);
1401 /* Make the process marker point into the process buffer (if any). */
1402 if (BUFFERP (buffer
))
1403 set_marker_both (XPROCESS (proc
)->mark
, buffer
,
1404 BUF_ZV (XBUFFER (buffer
)),
1405 BUF_ZV_BYTE (XBUFFER (buffer
)));
1408 /* Decide coding systems for communicating with the process. Here
1409 we don't setup the structure coding_system nor pay attention to
1410 unibyte mode. They are done in create_process. */
1412 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
1413 Lisp_Object coding_systems
= Qt
;
1414 Lisp_Object val
, *args2
;
1415 struct gcpro gcpro1
, gcpro2
;
1417 val
= Vcoding_system_for_read
;
1420 args2
= alloca ((nargs
+ 1) * sizeof *args2
);
1421 args2
[0] = Qstart_process
;
1422 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
1423 GCPRO2 (proc
, current_dir
);
1424 if (!NILP (program
))
1425 coding_systems
= Ffind_operation_coding_system (nargs
+ 1, args2
);
1427 if (CONSP (coding_systems
))
1428 val
= XCAR (coding_systems
);
1429 else if (CONSP (Vdefault_process_coding_system
))
1430 val
= XCAR (Vdefault_process_coding_system
);
1432 pset_decode_coding_system (XPROCESS (proc
), val
);
1434 val
= Vcoding_system_for_write
;
1437 if (EQ (coding_systems
, Qt
))
1439 args2
= alloca ((nargs
+ 1) * sizeof *args2
);
1440 args2
[0] = Qstart_process
;
1441 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
1442 GCPRO2 (proc
, current_dir
);
1443 if (!NILP (program
))
1444 coding_systems
= Ffind_operation_coding_system (nargs
+ 1, args2
);
1447 if (CONSP (coding_systems
))
1448 val
= XCDR (coding_systems
);
1449 else if (CONSP (Vdefault_process_coding_system
))
1450 val
= XCDR (Vdefault_process_coding_system
);
1452 pset_encode_coding_system (XPROCESS (proc
), val
);
1453 /* Note: At this moment, the above coding system may leave
1454 text-conversion or eol-conversion unspecified. They will be
1455 decided after we read output from the process and decode it by
1456 some coding system, or just before we actually send a text to
1461 pset_decoding_buf (XPROCESS (proc
), empty_unibyte_string
);
1462 XPROCESS (proc
)->decoding_carryover
= 0;
1463 pset_encoding_buf (XPROCESS (proc
), empty_unibyte_string
);
1465 XPROCESS (proc
)->inherit_coding_system_flag
1466 = !(NILP (buffer
) || !inherit_process_coding_system
);
1468 if (!NILP (program
))
1470 /* If program file name is not absolute, search our path for it.
1471 Put the name we will really use in TEM. */
1472 if (!IS_DIRECTORY_SEP (SREF (program
, 0))
1473 && !(SCHARS (program
) > 1
1474 && IS_DEVICE_SEP (SREF (program
, 1))))
1476 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1479 GCPRO4 (name
, program
, buffer
, current_dir
);
1480 openp (Vexec_path
, program
, Vexec_suffixes
, &tem
, make_number (X_OK
));
1483 report_file_error ("Searching for program", Fcons (program
, Qnil
));
1484 tem
= Fexpand_file_name (tem
, Qnil
);
1488 if (!NILP (Ffile_directory_p (program
)))
1489 error ("Specified program for new process is a directory");
1493 /* If program file name starts with /: for quoting a magic name,
1495 if (SBYTES (tem
) > 2 && SREF (tem
, 0) == '/'
1496 && SREF (tem
, 1) == ':')
1497 tem
= Fsubstring (tem
, make_number (2), Qnil
);
1500 Lisp_Object arg_encoding
= Qnil
;
1501 struct gcpro gcpro1
;
1504 /* Encode the file name and put it in NEW_ARGV.
1505 That's where the child will use it to execute the program. */
1506 tem
= Fcons (ENCODE_FILE (tem
), Qnil
);
1508 /* Here we encode arguments by the coding system used for sending
1509 data to the process. We don't support using different coding
1510 systems for encoding arguments and for encoding data sent to the
1513 for (i
= 3; i
< nargs
; i
++)
1515 tem
= Fcons (args
[i
], tem
);
1516 CHECK_STRING (XCAR (tem
));
1517 if (STRING_MULTIBYTE (XCAR (tem
)))
1519 if (NILP (arg_encoding
))
1520 arg_encoding
= (complement_process_encoding_system
1521 (XPROCESS (proc
)->encode_coding_system
));
1523 code_convert_string_norecord
1524 (XCAR (tem
), arg_encoding
, 1));
1531 /* Now that everything is encoded we can collect the strings into
1533 new_argv
= alloca ((nargs
- 1) * sizeof *new_argv
);
1534 new_argv
[nargs
- 2] = 0;
1536 for (i
= nargs
- 2; i
-- != 0; )
1538 new_argv
[i
] = SDATA (XCAR (tem
));
1542 create_process (proc
, (char **) new_argv
, current_dir
);
1547 return unbind_to (count
, proc
);
1550 /* This function is the unwind_protect form for Fstart_process. If
1551 PROC doesn't have its pid set, then we know someone has signaled
1552 an error and the process wasn't started successfully, so we should
1553 remove it from the process list. */
1555 start_process_unwind (Lisp_Object proc
)
1557 if (!PROCESSP (proc
))
1560 /* Was PROC started successfully?
1561 -2 is used for a pty with no process, eg for gdb. */
1562 if (XPROCESS (proc
)->pid
<= 0 && XPROCESS (proc
)->pid
!= -2)
1563 remove_process (proc
);
1569 create_process_1 (struct atimer
*timer
)
1571 /* Nothing to do. */
1576 create_process (Lisp_Object process
, char **new_argv
, Lisp_Object current_dir
)
1578 int inchannel
, outchannel
;
1582 int wait_child_setup
[2];
1587 /* Use volatile to protect variables from being clobbered by vfork. */
1588 volatile int forkin
, forkout
;
1589 volatile int pty_flag
= 0;
1590 volatile Lisp_Object lisp_pty_name
= Qnil
;
1591 volatile Lisp_Object encoded_current_dir
;
1593 inchannel
= outchannel
= -1;
1596 if (!NILP (Vprocess_connection_type
))
1597 outchannel
= inchannel
= allocate_pty ();
1601 #if ! defined (USG) || defined (USG_SUBTTY_WORKS)
1602 /* On most USG systems it does not work to open the pty's tty here,
1603 then close it and reopen it in the child. */
1604 /* Don't let this terminal become our controlling terminal
1605 (in case we don't have one). */
1606 forkout
= forkin
= emacs_open (pty_name
, O_RDWR
| O_NOCTTY
, 0);
1608 report_file_error ("Opening pty", Qnil
);
1610 forkin
= forkout
= -1;
1611 #endif /* not USG, or USG_SUBTTY_WORKS */
1613 lisp_pty_name
= build_string (pty_name
);
1616 #endif /* HAVE_PTYS */
1621 report_file_error ("Creating pipe", Qnil
);
1627 emacs_close (inchannel
);
1628 emacs_close (forkout
);
1629 report_file_error ("Creating pipe", Qnil
);
1639 tem
= pipe (wait_child_setup
);
1641 report_file_error ("Creating pipe", Qnil
);
1642 tem
= fcntl (wait_child_setup
[1], F_GETFD
, 0);
1644 tem
= fcntl (wait_child_setup
[1], F_SETFD
, tem
| FD_CLOEXEC
);
1647 emacs_close (wait_child_setup
[0]);
1648 emacs_close (wait_child_setup
[1]);
1649 report_file_error ("Setting file descriptor flags", Qnil
);
1654 fcntl (inchannel
, F_SETFL
, O_NONBLOCK
);
1655 fcntl (outchannel
, F_SETFL
, O_NONBLOCK
);
1657 /* Record this as an active process, with its channels.
1658 As a result, child_setup will close Emacs's side of the pipes. */
1659 chan_process
[inchannel
] = process
;
1660 XPROCESS (process
)->infd
= inchannel
;
1661 XPROCESS (process
)->outfd
= outchannel
;
1663 /* Previously we recorded the tty descriptor used in the subprocess.
1664 It was only used for getting the foreground tty process, so now
1665 we just reopen the device (see emacs_get_tty_pgrp) as this is
1666 more portable (see USG_SUBTTY_WORKS above). */
1668 XPROCESS (process
)->pty_flag
= pty_flag
;
1669 pset_status (XPROCESS (process
), Qrun
);
1671 FD_SET (inchannel
, &input_wait_mask
);
1672 FD_SET (inchannel
, &non_keyboard_wait_mask
);
1673 if (inchannel
> max_process_desc
)
1674 max_process_desc
= inchannel
;
1676 /* This may signal an error. */
1677 setup_process_coding_systems (process
);
1679 encoded_current_dir
= ENCODE_FILE (current_dir
);
1684 /* Block SIGCHLD until we have a chance to store the new fork's
1685 pid in its process structure. */
1686 sigemptyset (&blocked
);
1687 sigaddset (&blocked
, SIGCHLD
);
1688 pthread_sigmask (SIG_BLOCK
, &blocked
, 0);
1694 #endif /* not WINDOWSNT */
1696 int xforkin
= forkin
;
1697 int xforkout
= forkout
;
1699 /* Make the pty be the controlling terminal of the process. */
1701 /* First, disconnect its current controlling terminal. */
1702 /* We tried doing setsid only if pty_flag, but it caused
1703 process_set_signal to fail on SGI when using a pipe. */
1705 /* Make the pty's terminal the controlling terminal. */
1706 if (pty_flag
&& xforkin
>= 0)
1709 /* We ignore the return value
1710 because faith@cs.unc.edu says that is necessary on Linux. */
1711 ioctl (xforkin
, TIOCSCTTY
, 0);
1714 #if defined (LDISC1)
1715 if (pty_flag
&& xforkin
>= 0)
1718 tcgetattr (xforkin
, &t
);
1720 if (tcsetattr (xforkin
, TCSANOW
, &t
) < 0)
1721 emacs_write (1, "create_process/tcsetattr LDISC1 failed\n", 39);
1724 #if defined (NTTYDISC) && defined (TIOCSETD)
1725 if (pty_flag
&& xforkin
>= 0)
1727 /* Use new line discipline. */
1728 int ldisc
= NTTYDISC
;
1729 ioctl (xforkin
, TIOCSETD
, &ldisc
);
1734 /* In 4.3BSD, the TIOCSPGRP bug has been fixed, and now you
1735 can do TIOCSPGRP only to the process's controlling tty. */
1738 /* I wonder: would just ioctl (0, TIOCNOTTY, 0) work here?
1739 I can't test it since I don't have 4.3. */
1740 int j
= emacs_open ("/dev/tty", O_RDWR
, 0);
1743 ioctl (j
, TIOCNOTTY
, 0);
1747 #endif /* TIOCNOTTY */
1749 #if !defined (DONT_REOPEN_PTY)
1750 /*** There is a suggestion that this ought to be a
1751 conditional on TIOCSPGRP, or !defined TIOCSCTTY.
1752 Trying the latter gave the wrong results on Debian GNU/Linux 1.1;
1753 that system does seem to need this code, even though
1754 both TIOCSCTTY is defined. */
1755 /* Now close the pty (if we had it open) and reopen it.
1756 This makes the pty the controlling terminal of the subprocess. */
1760 /* I wonder if emacs_close (emacs_open (pty_name, ...))
1763 emacs_close (xforkin
);
1764 xforkout
= xforkin
= emacs_open (pty_name
, O_RDWR
, 0);
1768 emacs_write (1, "Couldn't open the pty terminal ", 31);
1769 emacs_write (1, pty_name
, strlen (pty_name
));
1770 emacs_write (1, "\n", 1);
1775 #endif /* not DONT_REOPEN_PTY */
1777 #ifdef SETUP_SLAVE_PTY
1782 #endif /* SETUP_SLAVE_PTY */
1784 /* On AIX, we've disabled SIGHUP above once we start a child on a pty.
1785 Now reenable it in the child, so it will die when we want it to. */
1787 signal (SIGHUP
, SIG_DFL
);
1789 #endif /* HAVE_PTYS */
1791 signal (SIGINT
, SIG_DFL
);
1792 signal (SIGQUIT
, SIG_DFL
);
1794 /* Emacs ignores SIGPIPE, but the child should not. */
1795 signal (SIGPIPE
, SIG_DFL
);
1798 /* Stop blocking signals in the child. */
1799 pthread_sigmask (SIG_SETMASK
, &empty_mask
, 0);
1803 child_setup_tty (xforkout
);
1805 pid
= child_setup (xforkin
, xforkout
, xforkout
,
1806 new_argv
, 1, encoded_current_dir
);
1807 #else /* not WINDOWSNT */
1808 emacs_close (wait_child_setup
[0]);
1809 child_setup (xforkin
, xforkout
, xforkout
,
1810 new_argv
, 1, encoded_current_dir
);
1811 #endif /* not WINDOWSNT */
1814 /* Back in the parent process. */
1816 XPROCESS (process
)->pid
= pid
;
1818 XPROCESS (process
)->alive
= 1;
1820 /* Stop blocking signals in the parent. */
1822 pthread_sigmask (SIG_SETMASK
, &empty_mask
, 0);
1829 emacs_close (forkin
);
1830 if (forkin
!= forkout
&& forkout
>= 0)
1831 emacs_close (forkout
);
1835 /* vfork succeeded. */
1838 register_child (pid
, inchannel
);
1839 #endif /* WINDOWSNT */
1841 /* If the subfork execv fails, and it exits,
1842 this close hangs. I don't know why.
1843 So have an interrupt jar it loose. */
1845 struct atimer
*timer
;
1846 EMACS_TIME offset
= make_emacs_time (1, 0);
1849 timer
= start_atimer (ATIMER_RELATIVE
, offset
, create_process_1
, 0);
1852 emacs_close (forkin
);
1854 cancel_atimer (timer
);
1858 if (forkin
!= forkout
&& forkout
>= 0)
1859 emacs_close (forkout
);
1861 pset_tty_name (XPROCESS (process
), lisp_pty_name
);
1864 /* Wait for child_setup to complete in case that vfork is
1865 actually defined as fork. The descriptor wait_child_setup[1]
1866 of a pipe is closed at the child side either by close-on-exec
1867 on successful execve or the _exit call in child_setup. */
1871 emacs_close (wait_child_setup
[1]);
1872 emacs_read (wait_child_setup
[0], &dummy
, 1);
1873 emacs_close (wait_child_setup
[0]);
1878 /* Now generate the error if vfork failed. */
1880 report_file_error ("Doing vfork", Qnil
);
1884 create_pty (Lisp_Object process
)
1886 int inchannel
, outchannel
;
1889 inchannel
= outchannel
= -1;
1892 if (!NILP (Vprocess_connection_type
))
1893 outchannel
= inchannel
= allocate_pty ();
1897 #if ! defined (USG) || defined (USG_SUBTTY_WORKS)
1898 /* On most USG systems it does not work to open the pty's tty here,
1899 then close it and reopen it in the child. */
1900 /* Don't let this terminal become our controlling terminal
1901 (in case we don't have one). */
1902 int forkout
= emacs_open (pty_name
, O_RDWR
| O_NOCTTY
, 0);
1904 report_file_error ("Opening pty", Qnil
);
1905 #if defined (DONT_REOPEN_PTY)
1906 /* In the case that vfork is defined as fork, the parent process
1907 (Emacs) may send some data before the child process completes
1908 tty options setup. So we setup tty before forking. */
1909 child_setup_tty (forkout
);
1910 #endif /* DONT_REOPEN_PTY */
1911 #endif /* not USG, or USG_SUBTTY_WORKS */
1914 #endif /* HAVE_PTYS */
1916 fcntl (inchannel
, F_SETFL
, O_NONBLOCK
);
1917 fcntl (outchannel
, F_SETFL
, O_NONBLOCK
);
1919 /* Record this as an active process, with its channels.
1920 As a result, child_setup will close Emacs's side of the pipes. */
1921 chan_process
[inchannel
] = process
;
1922 XPROCESS (process
)->infd
= inchannel
;
1923 XPROCESS (process
)->outfd
= outchannel
;
1925 /* Previously we recorded the tty descriptor used in the subprocess.
1926 It was only used for getting the foreground tty process, so now
1927 we just reopen the device (see emacs_get_tty_pgrp) as this is
1928 more portable (see USG_SUBTTY_WORKS above). */
1930 XPROCESS (process
)->pty_flag
= pty_flag
;
1931 pset_status (XPROCESS (process
), Qrun
);
1932 setup_process_coding_systems (process
);
1934 FD_SET (inchannel
, &input_wait_mask
);
1935 FD_SET (inchannel
, &non_keyboard_wait_mask
);
1936 if (inchannel
> max_process_desc
)
1937 max_process_desc
= inchannel
;
1939 XPROCESS (process
)->pid
= -2;
1942 pset_tty_name (XPROCESS (process
), build_string (pty_name
));
1945 pset_tty_name (XPROCESS (process
), Qnil
);
1949 /* Convert an internal struct sockaddr to a lisp object (vector or string).
1950 The address family of sa is not included in the result. */
1953 conv_sockaddr_to_lisp (struct sockaddr
*sa
, int len
)
1955 Lisp_Object address
;
1958 register struct Lisp_Vector
*p
;
1960 /* Workaround for a bug in getsockname on BSD: Names bound to
1961 sockets in the UNIX domain are inaccessible; getsockname returns
1962 a zero length name. */
1963 if (len
< offsetof (struct sockaddr
, sa_family
) + sizeof (sa
->sa_family
))
1964 return empty_unibyte_string
;
1966 switch (sa
->sa_family
)
1970 struct sockaddr_in
*sin
= (struct sockaddr_in
*) sa
;
1971 len
= sizeof (sin
->sin_addr
) + 1;
1972 address
= Fmake_vector (make_number (len
), Qnil
);
1973 p
= XVECTOR (address
);
1974 p
->contents
[--len
] = make_number (ntohs (sin
->sin_port
));
1975 cp
= (unsigned char *) &sin
->sin_addr
;
1981 struct sockaddr_in6
*sin6
= (struct sockaddr_in6
*) sa
;
1982 uint16_t *ip6
= (uint16_t *) &sin6
->sin6_addr
;
1983 len
= sizeof (sin6
->sin6_addr
)/2 + 1;
1984 address
= Fmake_vector (make_number (len
), Qnil
);
1985 p
= XVECTOR (address
);
1986 p
->contents
[--len
] = make_number (ntohs (sin6
->sin6_port
));
1987 for (i
= 0; i
< len
; i
++)
1988 p
->contents
[i
] = make_number (ntohs (ip6
[i
]));
1992 #ifdef HAVE_LOCAL_SOCKETS
1995 struct sockaddr_un
*sockun
= (struct sockaddr_un
*) sa
;
1996 for (i
= 0; i
< sizeof (sockun
->sun_path
); i
++)
1997 if (sockun
->sun_path
[i
] == 0)
1999 return make_unibyte_string (sockun
->sun_path
, i
);
2003 len
-= offsetof (struct sockaddr
, sa_family
) + sizeof (sa
->sa_family
);
2004 address
= Fcons (make_number (sa
->sa_family
),
2005 Fmake_vector (make_number (len
), Qnil
));
2006 p
= XVECTOR (XCDR (address
));
2007 cp
= (unsigned char *) &sa
->sa_family
+ sizeof (sa
->sa_family
);
2013 p
->contents
[i
++] = make_number (*cp
++);
2019 /* Get family and required size for sockaddr structure to hold ADDRESS. */
2022 get_lisp_to_sockaddr_size (Lisp_Object address
, int *familyp
)
2024 register struct Lisp_Vector
*p
;
2026 if (VECTORP (address
))
2028 p
= XVECTOR (address
);
2029 if (p
->header
.size
== 5)
2032 return sizeof (struct sockaddr_in
);
2035 else if (p
->header
.size
== 9)
2037 *familyp
= AF_INET6
;
2038 return sizeof (struct sockaddr_in6
);
2042 #ifdef HAVE_LOCAL_SOCKETS
2043 else if (STRINGP (address
))
2045 *familyp
= AF_LOCAL
;
2046 return sizeof (struct sockaddr_un
);
2049 else if (CONSP (address
) && TYPE_RANGED_INTEGERP (int, XCAR (address
))
2050 && VECTORP (XCDR (address
)))
2052 struct sockaddr
*sa
;
2053 *familyp
= XINT (XCAR (address
));
2054 p
= XVECTOR (XCDR (address
));
2055 return p
->header
.size
+ sizeof (sa
->sa_family
);
2060 /* Convert an address object (vector or string) to an internal sockaddr.
2062 The address format has been basically validated by
2063 get_lisp_to_sockaddr_size, but this does not mean FAMILY is valid;
2064 it could have come from user data. So if FAMILY is not valid,
2065 we return after zeroing *SA. */
2068 conv_lisp_to_sockaddr (int family
, Lisp_Object address
, struct sockaddr
*sa
, int len
)
2070 register struct Lisp_Vector
*p
;
2071 register unsigned char *cp
= NULL
;
2075 memset (sa
, 0, len
);
2077 if (VECTORP (address
))
2079 p
= XVECTOR (address
);
2080 if (family
== AF_INET
)
2082 struct sockaddr_in
*sin
= (struct sockaddr_in
*) sa
;
2083 len
= sizeof (sin
->sin_addr
) + 1;
2084 hostport
= XINT (p
->contents
[--len
]);
2085 sin
->sin_port
= htons (hostport
);
2086 cp
= (unsigned char *)&sin
->sin_addr
;
2087 sa
->sa_family
= family
;
2090 else if (family
== AF_INET6
)
2092 struct sockaddr_in6
*sin6
= (struct sockaddr_in6
*) sa
;
2093 uint16_t *ip6
= (uint16_t *)&sin6
->sin6_addr
;
2094 len
= sizeof (sin6
->sin6_addr
) + 1;
2095 hostport
= XINT (p
->contents
[--len
]);
2096 sin6
->sin6_port
= htons (hostport
);
2097 for (i
= 0; i
< len
; i
++)
2098 if (INTEGERP (p
->contents
[i
]))
2100 int j
= XFASTINT (p
->contents
[i
]) & 0xffff;
2103 sa
->sa_family
= family
;
2110 else if (STRINGP (address
))
2112 #ifdef HAVE_LOCAL_SOCKETS
2113 if (family
== AF_LOCAL
)
2115 struct sockaddr_un
*sockun
= (struct sockaddr_un
*) sa
;
2116 cp
= SDATA (address
);
2117 for (i
= 0; i
< sizeof (sockun
->sun_path
) && *cp
; i
++)
2118 sockun
->sun_path
[i
] = *cp
++;
2119 sa
->sa_family
= family
;
2126 p
= XVECTOR (XCDR (address
));
2127 cp
= (unsigned char *)sa
+ sizeof (sa
->sa_family
);
2130 for (i
= 0; i
< len
; i
++)
2131 if (INTEGERP (p
->contents
[i
]))
2132 *cp
++ = XFASTINT (p
->contents
[i
]) & 0xff;
2135 #ifdef DATAGRAM_SOCKETS
2136 DEFUN ("process-datagram-address", Fprocess_datagram_address
, Sprocess_datagram_address
,
2138 doc
: /* Get the current datagram address associated with PROCESS. */)
2139 (Lisp_Object process
)
2143 CHECK_PROCESS (process
);
2145 if (!DATAGRAM_CONN_P (process
))
2148 channel
= XPROCESS (process
)->infd
;
2149 return conv_sockaddr_to_lisp (datagram_address
[channel
].sa
,
2150 datagram_address
[channel
].len
);
2153 DEFUN ("set-process-datagram-address", Fset_process_datagram_address
, Sset_process_datagram_address
,
2155 doc
: /* Set the datagram address for PROCESS to ADDRESS.
2156 Returns nil upon error setting address, ADDRESS otherwise. */)
2157 (Lisp_Object process
, Lisp_Object address
)
2162 CHECK_PROCESS (process
);
2164 if (!DATAGRAM_CONN_P (process
))
2167 channel
= XPROCESS (process
)->infd
;
2169 len
= get_lisp_to_sockaddr_size (address
, &family
);
2170 if (datagram_address
[channel
].len
!= len
)
2172 conv_lisp_to_sockaddr (family
, address
, datagram_address
[channel
].sa
, len
);
2178 static const struct socket_options
{
2179 /* The name of this option. Should be lowercase version of option
2180 name without SO_ prefix. */
2182 /* Option level SOL_... */
2184 /* Option number SO_... */
2186 enum { SOPT_UNKNOWN
, SOPT_BOOL
, SOPT_INT
, SOPT_IFNAME
, SOPT_LINGER
} opttype
;
2187 enum { OPIX_NONE
=0, OPIX_MISC
=1, OPIX_REUSEADDR
=2 } optbit
;
2188 } socket_options
[] =
2190 #ifdef SO_BINDTODEVICE
2191 { ":bindtodevice", SOL_SOCKET
, SO_BINDTODEVICE
, SOPT_IFNAME
, OPIX_MISC
},
2194 { ":broadcast", SOL_SOCKET
, SO_BROADCAST
, SOPT_BOOL
, OPIX_MISC
},
2197 { ":dontroute", SOL_SOCKET
, SO_DONTROUTE
, SOPT_BOOL
, OPIX_MISC
},
2200 { ":keepalive", SOL_SOCKET
, SO_KEEPALIVE
, SOPT_BOOL
, OPIX_MISC
},
2203 { ":linger", SOL_SOCKET
, SO_LINGER
, SOPT_LINGER
, OPIX_MISC
},
2206 { ":oobinline", SOL_SOCKET
, SO_OOBINLINE
, SOPT_BOOL
, OPIX_MISC
},
2209 { ":priority", SOL_SOCKET
, SO_PRIORITY
, SOPT_INT
, OPIX_MISC
},
2212 { ":reuseaddr", SOL_SOCKET
, SO_REUSEADDR
, SOPT_BOOL
, OPIX_REUSEADDR
},
2214 { 0, 0, 0, SOPT_UNKNOWN
, OPIX_NONE
}
2217 /* Set option OPT to value VAL on socket S.
2219 Returns (1<<socket_options[OPT].optbit) if option is known, 0 otherwise.
2220 Signals an error if setting a known option fails.
2224 set_socket_option (int s
, Lisp_Object opt
, Lisp_Object val
)
2227 const struct socket_options
*sopt
;
2232 name
= SSDATA (SYMBOL_NAME (opt
));
2233 for (sopt
= socket_options
; sopt
->name
; sopt
++)
2234 if (strcmp (name
, sopt
->name
) == 0)
2237 switch (sopt
->opttype
)
2242 optval
= NILP (val
) ? 0 : 1;
2243 ret
= setsockopt (s
, sopt
->optlevel
, sopt
->optnum
,
2244 &optval
, sizeof (optval
));
2251 if (TYPE_RANGED_INTEGERP (int, val
))
2252 optval
= XINT (val
);
2254 error ("Bad option value for %s", name
);
2255 ret
= setsockopt (s
, sopt
->optlevel
, sopt
->optnum
,
2256 &optval
, sizeof (optval
));
2260 #ifdef SO_BINDTODEVICE
2263 char devname
[IFNAMSIZ
+1];
2265 /* This is broken, at least in the Linux 2.4 kernel.
2266 To unbind, the arg must be a zero integer, not the empty string.
2267 This should work on all systems. KFS. 2003-09-23. */
2268 memset (devname
, 0, sizeof devname
);
2271 char *arg
= SSDATA (val
);
2272 int len
= min (strlen (arg
), IFNAMSIZ
);
2273 memcpy (devname
, arg
, len
);
2275 else if (!NILP (val
))
2276 error ("Bad option value for %s", name
);
2277 ret
= setsockopt (s
, sopt
->optlevel
, sopt
->optnum
,
2286 struct linger linger
;
2289 linger
.l_linger
= 0;
2290 if (TYPE_RANGED_INTEGERP (int, val
))
2291 linger
.l_linger
= XINT (val
);
2293 linger
.l_onoff
= NILP (val
) ? 0 : 1;
2294 ret
= setsockopt (s
, sopt
->optlevel
, sopt
->optnum
,
2295 &linger
, sizeof (linger
));
2305 report_file_error ("Cannot set network option",
2306 Fcons (opt
, Fcons (val
, Qnil
)));
2307 return (1 << sopt
->optbit
);
2311 DEFUN ("set-network-process-option",
2312 Fset_network_process_option
, Sset_network_process_option
,
2314 doc
: /* For network process PROCESS set option OPTION to value VALUE.
2315 See `make-network-process' for a list of options and values.
2316 If optional fourth arg NO-ERROR is non-nil, don't signal an error if
2317 OPTION is not a supported option, return nil instead; otherwise return t. */)
2318 (Lisp_Object process
, Lisp_Object option
, Lisp_Object value
, Lisp_Object no_error
)
2321 struct Lisp_Process
*p
;
2323 CHECK_PROCESS (process
);
2324 p
= XPROCESS (process
);
2325 if (!NETCONN1_P (p
))
2326 error ("Process is not a network process");
2330 error ("Process is not running");
2332 if (set_socket_option (s
, option
, value
))
2334 pset_childp (p
, Fplist_put (p
->childp
, option
, value
));
2338 if (NILP (no_error
))
2339 error ("Unknown or unsupported option");
2345 DEFUN ("serial-process-configure",
2346 Fserial_process_configure
,
2347 Sserial_process_configure
,
2349 doc
: /* Configure speed, bytesize, etc. of a serial process.
2351 Arguments are specified as keyword/argument pairs. Attributes that
2352 are not given are re-initialized from the process's current
2353 configuration (available via the function `process-contact') or set to
2354 reasonable default values. The following arguments are defined:
2360 -- Any of these arguments can be given to identify the process that is
2361 to be configured. If none of these arguments is given, the current
2362 buffer's process is used.
2364 :speed SPEED -- SPEED is the speed of the serial port in bits per
2365 second, also called baud rate. Any value can be given for SPEED, but
2366 most serial ports work only at a few defined values between 1200 and
2367 115200, with 9600 being the most common value. If SPEED is nil, the
2368 serial port is not configured any further, i.e., all other arguments
2369 are ignored. This may be useful for special serial ports such as
2370 Bluetooth-to-serial converters which can only be configured through AT
2371 commands. A value of nil for SPEED can be used only when passed
2372 through `make-serial-process' or `serial-term'.
2374 :bytesize BYTESIZE -- BYTESIZE is the number of bits per byte, which
2375 can be 7 or 8. If BYTESIZE is not given or nil, a value of 8 is used.
2377 :parity PARITY -- PARITY can be nil (don't use parity), the symbol
2378 `odd' (use odd parity), or the symbol `even' (use even parity). If
2379 PARITY is not given, no parity is used.
2381 :stopbits STOPBITS -- STOPBITS is the number of stopbits used to
2382 terminate a byte transmission. STOPBITS can be 1 or 2. If STOPBITS
2383 is not given or nil, 1 stopbit is used.
2385 :flowcontrol FLOWCONTROL -- FLOWCONTROL determines the type of
2386 flowcontrol to be used, which is either nil (don't use flowcontrol),
2387 the symbol `hw' (use RTS/CTS hardware flowcontrol), or the symbol `sw'
2388 \(use XON/XOFF software flowcontrol). If FLOWCONTROL is not given, no
2389 flowcontrol is used.
2391 `serial-process-configure' is called by `make-serial-process' for the
2392 initial configuration of the serial port.
2396 \(serial-process-configure :process "/dev/ttyS0" :speed 1200)
2398 \(serial-process-configure
2399 :buffer "COM1" :stopbits 1 :parity 'odd :flowcontrol 'hw)
2401 \(serial-process-configure :port "\\\\.\\COM13" :bytesize 7)
2403 usage: (serial-process-configure &rest ARGS) */)
2404 (ptrdiff_t nargs
, Lisp_Object
*args
)
2406 struct Lisp_Process
*p
;
2407 Lisp_Object contact
= Qnil
;
2408 Lisp_Object proc
= Qnil
;
2409 struct gcpro gcpro1
;
2411 contact
= Flist (nargs
, args
);
2414 proc
= Fplist_get (contact
, QCprocess
);
2416 proc
= Fplist_get (contact
, QCname
);
2418 proc
= Fplist_get (contact
, QCbuffer
);
2420 proc
= Fplist_get (contact
, QCport
);
2421 proc
= get_process (proc
);
2422 p
= XPROCESS (proc
);
2423 if (!EQ (p
->type
, Qserial
))
2424 error ("Not a serial process");
2426 if (NILP (Fplist_get (p
->childp
, QCspeed
)))
2432 serial_configure (p
, contact
);
2438 /* Used by make-serial-process to recover from errors. */
2440 make_serial_process_unwind (Lisp_Object proc
)
2442 if (!PROCESSP (proc
))
2444 remove_process (proc
);
2448 DEFUN ("make-serial-process", Fmake_serial_process
, Smake_serial_process
,
2450 doc
: /* Create and return a serial port process.
2452 In Emacs, serial port connections are represented by process objects,
2453 so input and output work as for subprocesses, and `delete-process'
2454 closes a serial port connection. However, a serial process has no
2455 process id, it cannot be signaled, and the status codes are different
2456 from normal processes.
2458 `make-serial-process' creates a process and a buffer, on which you
2459 probably want to use `process-send-string'. Try \\[serial-term] for
2460 an interactive terminal. See below for examples.
2462 Arguments are specified as keyword/argument pairs. The following
2463 arguments are defined:
2465 :port PORT -- (mandatory) PORT is the path or name of the serial port.
2466 For example, this could be "/dev/ttyS0" on Unix. On Windows, this
2467 could be "COM1", or "\\\\.\\COM10" for ports higher than COM9 (double
2468 the backslashes in strings).
2470 :speed SPEED -- (mandatory) is handled by `serial-process-configure',
2471 which this function calls.
2473 :name NAME -- NAME is the name of the process. If NAME is not given,
2474 the value of PORT is used.
2476 :buffer BUFFER -- BUFFER is the buffer (or buffer-name) to associate
2477 with the process. Process output goes at the end of that buffer,
2478 unless you specify an output stream or filter function to handle the
2479 output. If BUFFER is not given, the value of NAME is used.
2481 :coding CODING -- If CODING is a symbol, it specifies the coding
2482 system used for both reading and writing for this process. If CODING
2483 is a cons (DECODING . ENCODING), DECODING is used for reading, and
2484 ENCODING is used for writing.
2486 :noquery BOOL -- When exiting Emacs, query the user if BOOL is nil and
2487 the process is running. If BOOL is not given, query before exiting.
2489 :stop BOOL -- Start process in the `stopped' state if BOOL is non-nil.
2490 In the stopped state, a serial process does not accept incoming data,
2491 but you can send outgoing data. The stopped state is cleared by
2492 `continue-process' and set by `stop-process'.
2494 :filter FILTER -- Install FILTER as the process filter.
2496 :sentinel SENTINEL -- Install SENTINEL as the process sentinel.
2498 :plist PLIST -- Install PLIST as the initial plist of the process.
2504 -- This function calls `serial-process-configure' to handle these
2507 The original argument list, possibly modified by later configuration,
2508 is available via the function `process-contact'.
2512 \(make-serial-process :port "/dev/ttyS0" :speed 9600)
2514 \(make-serial-process :port "COM1" :speed 115200 :stopbits 2)
2516 \(make-serial-process :port "\\\\.\\COM13" :speed 1200 :bytesize 7 :parity 'odd)
2518 \(make-serial-process :port "/dev/tty.BlueConsole-SPP-1" :speed nil)
2520 usage: (make-serial-process &rest ARGS) */)
2521 (ptrdiff_t nargs
, Lisp_Object
*args
)
2524 Lisp_Object proc
, contact
, port
;
2525 struct Lisp_Process
*p
;
2526 struct gcpro gcpro1
;
2527 Lisp_Object name
, buffer
;
2528 Lisp_Object tem
, val
;
2529 ptrdiff_t specpdl_count
= -1;
2534 contact
= Flist (nargs
, args
);
2537 port
= Fplist_get (contact
, QCport
);
2539 error ("No port specified");
2540 CHECK_STRING (port
);
2542 if (NILP (Fplist_member (contact
, QCspeed
)))
2543 error (":speed not specified");
2544 if (!NILP (Fplist_get (contact
, QCspeed
)))
2545 CHECK_NUMBER (Fplist_get (contact
, QCspeed
));
2547 name
= Fplist_get (contact
, QCname
);
2550 CHECK_STRING (name
);
2551 proc
= make_process (name
);
2552 specpdl_count
= SPECPDL_INDEX ();
2553 record_unwind_protect (make_serial_process_unwind
, proc
);
2554 p
= XPROCESS (proc
);
2556 fd
= serial_open (SSDATA (port
));
2559 if (fd
> max_process_desc
)
2560 max_process_desc
= fd
;
2561 chan_process
[fd
] = proc
;
2563 buffer
= Fplist_get (contact
, QCbuffer
);
2566 buffer
= Fget_buffer_create (buffer
);
2567 pset_buffer (p
, buffer
);
2569 pset_childp (p
, contact
);
2570 pset_plist (p
, Fcopy_sequence (Fplist_get (contact
, QCplist
)));
2571 pset_type (p
, Qserial
);
2572 pset_sentinel (p
, Fplist_get (contact
, QCsentinel
));
2573 pset_filter (p
, Fplist_get (contact
, QCfilter
));
2575 if (tem
= Fplist_get (contact
, QCnoquery
), !NILP (tem
))
2576 p
->kill_without_query
= 1;
2577 if (tem
= Fplist_get (contact
, QCstop
), !NILP (tem
))
2578 pset_command (p
, Qt
);
2581 if (!EQ (p
->command
, Qt
))
2583 FD_SET (fd
, &input_wait_mask
);
2584 FD_SET (fd
, &non_keyboard_wait_mask
);
2587 if (BUFFERP (buffer
))
2589 set_marker_both (p
->mark
, buffer
,
2590 BUF_ZV (XBUFFER (buffer
)),
2591 BUF_ZV_BYTE (XBUFFER (buffer
)));
2594 tem
= Fplist_member (contact
, QCcoding
);
2595 if (!NILP (tem
) && (!CONSP (tem
) || !CONSP (XCDR (tem
))))
2601 val
= XCAR (XCDR (tem
));
2605 else if (!NILP (Vcoding_system_for_read
))
2606 val
= Vcoding_system_for_read
;
2607 else if ((!NILP (buffer
) && NILP (BVAR (XBUFFER (buffer
), enable_multibyte_characters
)))
2608 || (NILP (buffer
) && NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
))))
2610 pset_decode_coding_system (p
, val
);
2615 val
= XCAR (XCDR (tem
));
2619 else if (!NILP (Vcoding_system_for_write
))
2620 val
= Vcoding_system_for_write
;
2621 else if ((!NILP (buffer
) && NILP (BVAR (XBUFFER (buffer
), enable_multibyte_characters
)))
2622 || (NILP (buffer
) && NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
))))
2624 pset_encode_coding_system (p
, val
);
2626 setup_process_coding_systems (proc
);
2627 pset_decoding_buf (p
, empty_unibyte_string
);
2628 p
->decoding_carryover
= 0;
2629 pset_encoding_buf (p
, empty_unibyte_string
);
2630 p
->inherit_coding_system_flag
2631 = !(!NILP (tem
) || NILP (buffer
) || !inherit_process_coding_system
);
2633 Fserial_process_configure (nargs
, args
);
2635 specpdl_ptr
= specpdl
+ specpdl_count
;
2641 /* Create a network stream/datagram client/server process. Treated
2642 exactly like a normal process when reading and writing. Primary
2643 differences are in status display and process deletion. A network
2644 connection has no PID; you cannot signal it. All you can do is
2645 stop/continue it and deactivate/close it via delete-process */
2647 DEFUN ("make-network-process", Fmake_network_process
, Smake_network_process
,
2649 doc
: /* Create and return a network server or client process.
2651 In Emacs, network connections are represented by process objects, so
2652 input and output work as for subprocesses and `delete-process' closes
2653 a network connection. However, a network process has no process id,
2654 it cannot be signaled, and the status codes are different from normal
2657 Arguments are specified as keyword/argument pairs. The following
2658 arguments are defined:
2660 :name NAME -- NAME is name for process. It is modified if necessary
2663 :buffer BUFFER -- BUFFER is the buffer (or buffer-name) to associate
2664 with the process. Process output goes at end of that buffer, unless
2665 you specify an output stream or filter function to handle the output.
2666 BUFFER may be also nil, meaning that this process is not associated
2669 :host HOST -- HOST is name of the host to connect to, or its IP
2670 address. The symbol `local' specifies the local host. If specified
2671 for a server process, it must be a valid name or address for the local
2672 host, and only clients connecting to that address will be accepted.
2674 :service SERVICE -- SERVICE is name of the service desired, or an
2675 integer specifying a port number to connect to. If SERVICE is t,
2676 a random port number is selected for the server. (If Emacs was
2677 compiled with getaddrinfo, a port number can also be specified as a
2678 string, e.g. "80", as well as an integer. This is not portable.)
2680 :type TYPE -- TYPE is the type of connection. The default (nil) is a
2681 stream type connection, `datagram' creates a datagram type connection,
2682 `seqpacket' creates a reliable datagram connection.
2684 :family FAMILY -- FAMILY is the address (and protocol) family for the
2685 service specified by HOST and SERVICE. The default (nil) is to use
2686 whatever address family (IPv4 or IPv6) that is defined for the host
2687 and port number specified by HOST and SERVICE. Other address families
2689 local -- for a local (i.e. UNIX) address specified by SERVICE.
2690 ipv4 -- use IPv4 address family only.
2691 ipv6 -- use IPv6 address family only.
2693 :local ADDRESS -- ADDRESS is the local address used for the connection.
2694 This parameter is ignored when opening a client process. When specified
2695 for a server process, the FAMILY, HOST and SERVICE args are ignored.
2697 :remote ADDRESS -- ADDRESS is the remote partner's address for the
2698 connection. This parameter is ignored when opening a stream server
2699 process. For a datagram server process, it specifies the initial
2700 setting of the remote datagram address. When specified for a client
2701 process, the FAMILY, HOST, and SERVICE args are ignored.
2703 The format of ADDRESS depends on the address family:
2704 - An IPv4 address is represented as an vector of integers [A B C D P]
2705 corresponding to numeric IP address A.B.C.D and port number P.
2706 - A local address is represented as a string with the address in the
2707 local address space.
2708 - An "unsupported family" address is represented by a cons (F . AV)
2709 where F is the family number and AV is a vector containing the socket
2710 address data with one element per address data byte. Do not rely on
2711 this format in portable code, as it may depend on implementation
2712 defined constants, data sizes, and data structure alignment.
2714 :coding CODING -- If CODING is a symbol, it specifies the coding
2715 system used for both reading and writing for this process. If CODING
2716 is a cons (DECODING . ENCODING), DECODING is used for reading, and
2717 ENCODING is used for writing.
2719 :nowait BOOL -- If BOOL is non-nil for a stream type client process,
2720 return without waiting for the connection to complete; instead, the
2721 sentinel function will be called with second arg matching "open" (if
2722 successful) or "failed" when the connect completes. Default is to use
2723 a blocking connect (i.e. wait) for stream type connections.
2725 :noquery BOOL -- Query the user unless BOOL is non-nil, and process is
2726 running when Emacs is exited.
2728 :stop BOOL -- Start process in the `stopped' state if BOOL non-nil.
2729 In the stopped state, a server process does not accept new
2730 connections, and a client process does not handle incoming traffic.
2731 The stopped state is cleared by `continue-process' and set by
2734 :filter FILTER -- Install FILTER as the process filter.
2736 :filter-multibyte BOOL -- If BOOL is non-nil, strings given to the
2737 process filter are multibyte, otherwise they are unibyte.
2738 If this keyword is not specified, the strings are multibyte if
2739 the default value of `enable-multibyte-characters' is non-nil.
2741 :sentinel SENTINEL -- Install SENTINEL as the process sentinel.
2743 :log LOG -- Install LOG as the server process log function. This
2744 function is called when the server accepts a network connection from a
2745 client. The arguments are SERVER, CLIENT, and MESSAGE, where SERVER
2746 is the server process, CLIENT is the new process for the connection,
2747 and MESSAGE is a string.
2749 :plist PLIST -- Install PLIST as the new process' initial plist.
2751 :server QLEN -- if QLEN is non-nil, create a server process for the
2752 specified FAMILY, SERVICE, and connection type (stream or datagram).
2753 If QLEN is an integer, it is used as the max. length of the server's
2754 pending connection queue (also known as the backlog); the default
2755 queue length is 5. Default is to create a client process.
2757 The following network options can be specified for this connection:
2759 :broadcast BOOL -- Allow send and receive of datagram broadcasts.
2760 :dontroute BOOL -- Only send to directly connected hosts.
2761 :keepalive BOOL -- Send keep-alive messages on network stream.
2762 :linger BOOL or TIMEOUT -- Send queued messages before closing.
2763 :oobinline BOOL -- Place out-of-band data in receive data stream.
2764 :priority INT -- Set protocol defined priority for sent packets.
2765 :reuseaddr BOOL -- Allow reusing a recently used local address
2766 (this is allowed by default for a server process).
2767 :bindtodevice NAME -- bind to interface NAME. Using this may require
2768 special privileges on some systems.
2770 Consult the relevant system programmer's manual pages for more
2771 information on using these options.
2774 A server process will listen for and accept connections from clients.
2775 When a client connection is accepted, a new network process is created
2776 for the connection with the following parameters:
2778 - The client's process name is constructed by concatenating the server
2779 process' NAME and a client identification string.
2780 - If the FILTER argument is non-nil, the client process will not get a
2781 separate process buffer; otherwise, the client's process buffer is a newly
2782 created buffer named after the server process' BUFFER name or process
2783 NAME concatenated with the client identification string.
2784 - The connection type and the process filter and sentinel parameters are
2785 inherited from the server process' TYPE, FILTER and SENTINEL.
2786 - The client process' contact info is set according to the client's
2787 addressing information (typically an IP address and a port number).
2788 - The client process' plist is initialized from the server's plist.
2790 Notice that the FILTER and SENTINEL args are never used directly by
2791 the server process. Also, the BUFFER argument is not used directly by
2792 the server process, but via the optional :log function, accepted (and
2793 failed) connections may be logged in the server process' buffer.
2795 The original argument list, modified with the actual connection
2796 information, is available via the `process-contact' function.
2798 usage: (make-network-process &rest ARGS) */)
2799 (ptrdiff_t nargs
, Lisp_Object
*args
)
2802 Lisp_Object contact
;
2803 struct Lisp_Process
*p
;
2804 #ifdef HAVE_GETADDRINFO
2805 struct addrinfo ai
, *res
, *lres
;
2806 struct addrinfo hints
;
2807 const char *portstring
;
2809 #else /* HAVE_GETADDRINFO */
2810 struct _emacs_addrinfo
2816 struct sockaddr
*ai_addr
;
2817 struct _emacs_addrinfo
*ai_next
;
2819 #endif /* HAVE_GETADDRINFO */
2820 struct sockaddr_in address_in
;
2821 #ifdef HAVE_LOCAL_SOCKETS
2822 struct sockaddr_un address_un
;
2827 int s
= -1, outch
, inch
;
2828 struct gcpro gcpro1
;
2829 ptrdiff_t count
= SPECPDL_INDEX ();
2831 Lisp_Object QCaddress
; /* one of QClocal or QCremote */
2833 Lisp_Object name
, buffer
, host
, service
, address
;
2834 Lisp_Object filter
, sentinel
;
2835 int is_non_blocking_client
= 0;
2836 int is_server
= 0, backlog
= 5;
2843 /* Save arguments for process-contact and clone-process. */
2844 contact
= Flist (nargs
, args
);
2848 /* Ensure socket support is loaded if available. */
2849 init_winsock (TRUE
);
2852 /* :type TYPE (nil: stream, datagram */
2853 tem
= Fplist_get (contact
, QCtype
);
2855 socktype
= SOCK_STREAM
;
2856 #ifdef DATAGRAM_SOCKETS
2857 else if (EQ (tem
, Qdatagram
))
2858 socktype
= SOCK_DGRAM
;
2860 #ifdef HAVE_SEQPACKET
2861 else if (EQ (tem
, Qseqpacket
))
2862 socktype
= SOCK_SEQPACKET
;
2865 error ("Unsupported connection type");
2868 tem
= Fplist_get (contact
, QCserver
);
2871 /* Don't support network sockets when non-blocking mode is
2872 not available, since a blocked Emacs is not useful. */
2874 if (TYPE_RANGED_INTEGERP (int, tem
))
2875 backlog
= XINT (tem
);
2878 /* Make QCaddress an alias for :local (server) or :remote (client). */
2879 QCaddress
= is_server
? QClocal
: QCremote
;
2882 if (!is_server
&& socktype
!= SOCK_DGRAM
2883 && (tem
= Fplist_get (contact
, QCnowait
), !NILP (tem
)))
2885 #ifndef NON_BLOCKING_CONNECT
2886 error ("Non-blocking connect not supported");
2888 is_non_blocking_client
= 1;
2892 name
= Fplist_get (contact
, QCname
);
2893 buffer
= Fplist_get (contact
, QCbuffer
);
2894 filter
= Fplist_get (contact
, QCfilter
);
2895 sentinel
= Fplist_get (contact
, QCsentinel
);
2897 CHECK_STRING (name
);
2899 /* Initialize addrinfo structure in case we don't use getaddrinfo. */
2900 ai
.ai_socktype
= socktype
;
2905 /* :local ADDRESS or :remote ADDRESS */
2906 address
= Fplist_get (contact
, QCaddress
);
2907 if (!NILP (address
))
2909 host
= service
= Qnil
;
2911 if (!(ai
.ai_addrlen
= get_lisp_to_sockaddr_size (address
, &family
)))
2912 error ("Malformed :address");
2913 ai
.ai_family
= family
;
2914 ai
.ai_addr
= alloca (ai
.ai_addrlen
);
2915 conv_lisp_to_sockaddr (family
, address
, ai
.ai_addr
, ai
.ai_addrlen
);
2919 /* :family FAMILY -- nil (for Inet), local, or integer. */
2920 tem
= Fplist_get (contact
, QCfamily
);
2923 #if defined (HAVE_GETADDRINFO) && defined (AF_INET6)
2929 #ifdef HAVE_LOCAL_SOCKETS
2930 else if (EQ (tem
, Qlocal
))
2934 else if (EQ (tem
, Qipv6
))
2937 else if (EQ (tem
, Qipv4
))
2939 else if (TYPE_RANGED_INTEGERP (int, tem
))
2940 family
= XINT (tem
);
2942 error ("Unknown address family");
2944 ai
.ai_family
= family
;
2946 /* :service SERVICE -- string, integer (port number), or t (random port). */
2947 service
= Fplist_get (contact
, QCservice
);
2949 /* :host HOST -- hostname, ip address, or 'local for localhost. */
2950 host
= Fplist_get (contact
, QChost
);
2953 if (EQ (host
, Qlocal
))
2954 /* Depending on setup, "localhost" may map to different IPv4 and/or
2955 IPv6 addresses, so it's better to be explicit. (Bug#6781) */
2956 host
= build_string ("127.0.0.1");
2957 CHECK_STRING (host
);
2960 #ifdef HAVE_LOCAL_SOCKETS
2961 if (family
== AF_LOCAL
)
2965 message (":family local ignores the :host \"%s\" property",
2967 contact
= Fplist_put (contact
, QChost
, Qnil
);
2970 CHECK_STRING (service
);
2971 memset (&address_un
, 0, sizeof address_un
);
2972 address_un
.sun_family
= AF_LOCAL
;
2973 if (sizeof address_un
.sun_path
<= SBYTES (service
))
2974 error ("Service name too long");
2975 strcpy (address_un
.sun_path
, SSDATA (service
));
2976 ai
.ai_addr
= (struct sockaddr
*) &address_un
;
2977 ai
.ai_addrlen
= sizeof address_un
;
2982 /* Slow down polling to every ten seconds.
2983 Some kernels have a bug which causes retrying connect to fail
2984 after a connect. Polling can interfere with gethostbyname too. */
2985 #ifdef POLL_FOR_INPUT
2986 if (socktype
!= SOCK_DGRAM
)
2988 record_unwind_protect (unwind_stop_other_atimers
, Qnil
);
2989 bind_polling_period (10);
2993 #ifdef HAVE_GETADDRINFO
2994 /* If we have a host, use getaddrinfo to resolve both host and service.
2995 Otherwise, use getservbyname to lookup the service. */
2999 /* SERVICE can either be a string or int.
3000 Convert to a C string for later use by getaddrinfo. */
3001 if (EQ (service
, Qt
))
3003 else if (INTEGERP (service
))
3005 sprintf (portbuf
, "%"pI
"d", XINT (service
));
3006 portstring
= portbuf
;
3010 CHECK_STRING (service
);
3011 portstring
= SSDATA (service
);
3016 memset (&hints
, 0, sizeof (hints
));
3018 hints
.ai_family
= family
;
3019 hints
.ai_socktype
= socktype
;
3020 hints
.ai_protocol
= 0;
3022 #ifdef HAVE_RES_INIT
3026 ret
= getaddrinfo (SSDATA (host
), portstring
, &hints
, &res
);
3028 #ifdef HAVE_GAI_STRERROR
3029 error ("%s/%s %s", SSDATA (host
), portstring
, gai_strerror (ret
));
3031 error ("%s/%s getaddrinfo error %d", SSDATA (host
), portstring
, ret
);
3037 #endif /* HAVE_GETADDRINFO */
3039 /* We end up here if getaddrinfo is not defined, or in case no hostname
3040 has been specified (e.g. for a local server process). */
3042 if (EQ (service
, Qt
))
3044 else if (INTEGERP (service
))
3045 port
= htons ((unsigned short) XINT (service
));
3048 struct servent
*svc_info
;
3049 CHECK_STRING (service
);
3050 svc_info
= getservbyname (SSDATA (service
),
3051 (socktype
== SOCK_DGRAM
? "udp" : "tcp"));
3053 error ("Unknown service: %s", SDATA (service
));
3054 port
= svc_info
->s_port
;
3057 memset (&address_in
, 0, sizeof address_in
);
3058 address_in
.sin_family
= family
;
3059 address_in
.sin_addr
.s_addr
= INADDR_ANY
;
3060 address_in
.sin_port
= port
;
3062 #ifndef HAVE_GETADDRINFO
3065 struct hostent
*host_info_ptr
;
3067 /* gethostbyname may fail with TRY_AGAIN, but we don't honor that,
3068 as it may `hang' Emacs for a very long time. */
3072 #ifdef HAVE_RES_INIT
3076 host_info_ptr
= gethostbyname (SDATA (host
));
3081 memcpy (&address_in
.sin_addr
, host_info_ptr
->h_addr
,
3082 host_info_ptr
->h_length
);
3083 family
= host_info_ptr
->h_addrtype
;
3084 address_in
.sin_family
= family
;
3087 /* Attempt to interpret host as numeric inet address */
3089 unsigned long numeric_addr
;
3090 numeric_addr
= inet_addr (SSDATA (host
));
3091 if (numeric_addr
== -1)
3092 error ("Unknown host \"%s\"", SDATA (host
));
3094 memcpy (&address_in
.sin_addr
, &numeric_addr
,
3095 sizeof (address_in
.sin_addr
));
3099 #endif /* not HAVE_GETADDRINFO */
3101 ai
.ai_family
= family
;
3102 ai
.ai_addr
= (struct sockaddr
*) &address_in
;
3103 ai
.ai_addrlen
= sizeof address_in
;
3107 /* Do this in case we never enter the for-loop below. */
3108 count1
= SPECPDL_INDEX ();
3111 for (lres
= res
; lres
; lres
= lres
->ai_next
)
3120 s
= socket (lres
->ai_family
, lres
->ai_socktype
, lres
->ai_protocol
);
3127 #ifdef DATAGRAM_SOCKETS
3128 if (!is_server
&& socktype
== SOCK_DGRAM
)
3130 #endif /* DATAGRAM_SOCKETS */
3132 #ifdef NON_BLOCKING_CONNECT
3133 if (is_non_blocking_client
)
3135 ret
= fcntl (s
, F_SETFL
, O_NONBLOCK
);
3146 /* Make us close S if quit. */
3147 record_unwind_protect (close_file_unwind
, make_number (s
));
3149 /* Parse network options in the arg list.
3150 We simply ignore anything which isn't a known option (including other keywords).
3151 An error is signaled if setting a known option fails. */
3152 for (optn
= optbits
= 0; optn
< nargs
-1; optn
+= 2)
3153 optbits
|= set_socket_option (s
, args
[optn
], args
[optn
+1]);
3157 /* Configure as a server socket. */
3159 /* SO_REUSEADDR = 1 is default for server sockets; must specify
3160 explicit :reuseaddr key to override this. */
3161 #ifdef HAVE_LOCAL_SOCKETS
3162 if (family
!= AF_LOCAL
)
3164 if (!(optbits
& (1 << OPIX_REUSEADDR
)))
3167 if (setsockopt (s
, SOL_SOCKET
, SO_REUSEADDR
, &optval
, sizeof optval
))
3168 report_file_error ("Cannot set reuse option on server socket", Qnil
);
3171 if (bind (s
, lres
->ai_addr
, lres
->ai_addrlen
))
3172 report_file_error ("Cannot bind server socket", Qnil
);
3174 #ifdef HAVE_GETSOCKNAME
3175 if (EQ (service
, Qt
))
3177 struct sockaddr_in sa1
;
3178 socklen_t len1
= sizeof (sa1
);
3179 if (getsockname (s
, (struct sockaddr
*)&sa1
, &len1
) == 0)
3181 ((struct sockaddr_in
*)(lres
->ai_addr
))->sin_port
= sa1
.sin_port
;
3182 service
= make_number (ntohs (sa1
.sin_port
));
3183 contact
= Fplist_put (contact
, QCservice
, service
);
3188 if (socktype
!= SOCK_DGRAM
&& listen (s
, backlog
))
3189 report_file_error ("Cannot listen on server socket", Qnil
);
3197 ret
= connect (s
, lres
->ai_addr
, lres
->ai_addrlen
);
3200 if (ret
== 0 || xerrno
== EISCONN
)
3202 /* The unwind-protect will be discarded afterwards.
3203 Likewise for immediate_quit. */
3207 #ifdef NON_BLOCKING_CONNECT
3209 if (is_non_blocking_client
&& xerrno
== EINPROGRESS
)
3213 if (is_non_blocking_client
&& xerrno
== EWOULDBLOCK
)
3220 if (xerrno
== EINTR
)
3222 /* Unlike most other syscalls connect() cannot be called
3223 again. (That would return EALREADY.) The proper way to
3224 wait for completion is pselect(). */
3232 sc
= pselect (s
+ 1, NULL
, &fdset
, NULL
, NULL
, NULL
);
3238 report_file_error ("select failed", Qnil
);
3242 len
= sizeof xerrno
;
3243 eassert (FD_ISSET (s
, &fdset
));
3244 if (getsockopt (s
, SOL_SOCKET
, SO_ERROR
, &xerrno
, &len
) == -1)
3245 report_file_error ("getsockopt failed", Qnil
);
3247 errno
= xerrno
, report_file_error ("error during connect", Qnil
);
3251 #endif /* !WINDOWSNT */
3255 /* Discard the unwind protect closing S. */
3256 specpdl_ptr
= specpdl
+ count1
;
3261 if (xerrno
== EINTR
)
3268 #ifdef DATAGRAM_SOCKETS
3269 if (socktype
== SOCK_DGRAM
)
3271 if (datagram_address
[s
].sa
)
3273 datagram_address
[s
].sa
= xmalloc (lres
->ai_addrlen
);
3274 datagram_address
[s
].len
= lres
->ai_addrlen
;
3278 memset (datagram_address
[s
].sa
, 0, lres
->ai_addrlen
);
3279 if (remote
= Fplist_get (contact
, QCremote
), !NILP (remote
))
3282 rlen
= get_lisp_to_sockaddr_size (remote
, &rfamily
);
3283 if (rfamily
== lres
->ai_family
&& rlen
== lres
->ai_addrlen
)
3284 conv_lisp_to_sockaddr (rfamily
, remote
,
3285 datagram_address
[s
].sa
, rlen
);
3289 memcpy (datagram_address
[s
].sa
, lres
->ai_addr
, lres
->ai_addrlen
);
3292 contact
= Fplist_put (contact
, QCaddress
,
3293 conv_sockaddr_to_lisp (lres
->ai_addr
, lres
->ai_addrlen
));
3294 #ifdef HAVE_GETSOCKNAME
3297 struct sockaddr_in sa1
;
3298 socklen_t len1
= sizeof (sa1
);
3299 if (getsockname (s
, (struct sockaddr
*)&sa1
, &len1
) == 0)
3300 contact
= Fplist_put (contact
, QClocal
,
3301 conv_sockaddr_to_lisp ((struct sockaddr
*)&sa1
, len1
));
3308 #ifdef HAVE_GETADDRINFO
3317 /* Discard the unwind protect for closing S, if any. */
3318 specpdl_ptr
= specpdl
+ count1
;
3320 /* Unwind bind_polling_period and request_sigio. */
3321 unbind_to (count
, Qnil
);
3325 /* If non-blocking got this far - and failed - assume non-blocking is
3326 not supported after all. This is probably a wrong assumption, but
3327 the normal blocking calls to open-network-stream handles this error
3329 if (is_non_blocking_client
)
3334 report_file_error ("make server process failed", contact
);
3336 report_file_error ("make client process failed", contact
);
3343 buffer
= Fget_buffer_create (buffer
);
3344 proc
= make_process (name
);
3346 chan_process
[inch
] = proc
;
3348 fcntl (inch
, F_SETFL
, O_NONBLOCK
);
3350 p
= XPROCESS (proc
);
3352 pset_childp (p
, contact
);
3353 pset_plist (p
, Fcopy_sequence (Fplist_get (contact
, QCplist
)));
3354 pset_type (p
, Qnetwork
);
3356 pset_buffer (p
, buffer
);
3357 pset_sentinel (p
, sentinel
);
3358 pset_filter (p
, filter
);
3359 pset_log (p
, Fplist_get (contact
, QClog
));
3360 if (tem
= Fplist_get (contact
, QCnoquery
), !NILP (tem
))
3361 p
->kill_without_query
= 1;
3362 if ((tem
= Fplist_get (contact
, QCstop
), !NILP (tem
)))
3363 pset_command (p
, Qt
);
3367 if (is_server
&& socktype
!= SOCK_DGRAM
)
3368 pset_status (p
, Qlisten
);
3370 /* Make the process marker point into the process buffer (if any). */
3371 if (BUFFERP (buffer
))
3372 set_marker_both (p
->mark
, buffer
,
3373 BUF_ZV (XBUFFER (buffer
)),
3374 BUF_ZV_BYTE (XBUFFER (buffer
)));
3376 #ifdef NON_BLOCKING_CONNECT
3377 if (is_non_blocking_client
)
3379 /* We may get here if connect did succeed immediately. However,
3380 in that case, we still need to signal this like a non-blocking
3382 pset_status (p
, Qconnect
);
3383 if (!FD_ISSET (inch
, &connect_wait_mask
))
3385 FD_SET (inch
, &connect_wait_mask
);
3386 FD_SET (inch
, &write_mask
);
3387 num_pending_connects
++;
3392 /* A server may have a client filter setting of Qt, but it must
3393 still listen for incoming connects unless it is stopped. */
3394 if ((!EQ (p
->filter
, Qt
) && !EQ (p
->command
, Qt
))
3395 || (EQ (p
->status
, Qlisten
) && NILP (p
->command
)))
3397 FD_SET (inch
, &input_wait_mask
);
3398 FD_SET (inch
, &non_keyboard_wait_mask
);
3401 if (inch
> max_process_desc
)
3402 max_process_desc
= inch
;
3404 tem
= Fplist_member (contact
, QCcoding
);
3405 if (!NILP (tem
) && (!CONSP (tem
) || !CONSP (XCDR (tem
))))
3406 tem
= Qnil
; /* No error message (too late!). */
3409 /* Setup coding systems for communicating with the network stream. */
3410 struct gcpro gcpro1
;
3411 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
3412 Lisp_Object coding_systems
= Qt
;
3413 Lisp_Object fargs
[5], val
;
3417 val
= XCAR (XCDR (tem
));
3421 else if (!NILP (Vcoding_system_for_read
))
3422 val
= Vcoding_system_for_read
;
3423 else if ((!NILP (buffer
) && NILP (BVAR (XBUFFER (buffer
), enable_multibyte_characters
)))
3424 || (NILP (buffer
) && NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
))))
3425 /* We dare not decode end-of-line format by setting VAL to
3426 Qraw_text, because the existing Emacs Lisp libraries
3427 assume that they receive bare code including a sequence of
3432 if (NILP (host
) || NILP (service
))
3433 coding_systems
= Qnil
;
3436 fargs
[0] = Qopen_network_stream
, fargs
[1] = name
,
3437 fargs
[2] = buffer
, fargs
[3] = host
, fargs
[4] = service
;
3439 coding_systems
= Ffind_operation_coding_system (5, fargs
);
3442 if (CONSP (coding_systems
))
3443 val
= XCAR (coding_systems
);
3444 else if (CONSP (Vdefault_process_coding_system
))
3445 val
= XCAR (Vdefault_process_coding_system
);
3449 pset_decode_coding_system (p
, val
);
3453 val
= XCAR (XCDR (tem
));
3457 else if (!NILP (Vcoding_system_for_write
))
3458 val
= Vcoding_system_for_write
;
3459 else if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3463 if (EQ (coding_systems
, Qt
))
3465 if (NILP (host
) || NILP (service
))
3466 coding_systems
= Qnil
;
3469 fargs
[0] = Qopen_network_stream
, fargs
[1] = name
,
3470 fargs
[2] = buffer
, fargs
[3] = host
, fargs
[4] = service
;
3472 coding_systems
= Ffind_operation_coding_system (5, fargs
);
3476 if (CONSP (coding_systems
))
3477 val
= XCDR (coding_systems
);
3478 else if (CONSP (Vdefault_process_coding_system
))
3479 val
= XCDR (Vdefault_process_coding_system
);
3483 pset_encode_coding_system (p
, val
);
3485 setup_process_coding_systems (proc
);
3487 pset_decoding_buf (p
, empty_unibyte_string
);
3488 p
->decoding_carryover
= 0;
3489 pset_encoding_buf (p
, empty_unibyte_string
);
3491 p
->inherit_coding_system_flag
3492 = !(!NILP (tem
) || NILP (buffer
) || !inherit_process_coding_system
);
3499 #if defined (HAVE_NET_IF_H)
3502 DEFUN ("network-interface-list", Fnetwork_interface_list
, Snetwork_interface_list
, 0, 0, 0,
3503 doc
: /* Return an alist of all network interfaces and their network address.
3504 Each element is a cons, the car of which is a string containing the
3505 interface name, and the cdr is the network address in internal
3506 format; see the description of ADDRESS in `make-network-process'. */)
3509 struct ifconf ifconf
;
3510 struct ifreq
*ifreq
;
3512 ptrdiff_t buf_size
= 512;
3516 s
= socket (AF_INET
, SOCK_STREAM
, 0);
3522 buf
= xpalloc (buf
, &buf_size
, 1, INT_MAX
, 1);
3523 ifconf
.ifc_buf
= buf
;
3524 ifconf
.ifc_len
= buf_size
;
3525 if (ioctl (s
, SIOCGIFCONF
, &ifconf
))
3532 while (ifconf
.ifc_len
== buf_size
);
3537 ifreq
= ifconf
.ifc_req
;
3538 while ((char *) ifreq
< (char *) ifconf
.ifc_req
+ ifconf
.ifc_len
)
3540 struct ifreq
*ifq
= ifreq
;
3541 #ifdef HAVE_STRUCT_IFREQ_IFR_ADDR_SA_LEN
3542 #define SIZEOF_IFREQ(sif) \
3543 ((sif)->ifr_addr.sa_len < sizeof (struct sockaddr) \
3544 ? sizeof (*(sif)) : sizeof ((sif)->ifr_name) + (sif)->ifr_addr.sa_len)
3546 int len
= SIZEOF_IFREQ (ifq
);
3548 int len
= sizeof (*ifreq
);
3550 char namebuf
[sizeof (ifq
->ifr_name
) + 1];
3552 ifreq
= (struct ifreq
*) ((char *) ifreq
+ len
);
3554 if (ifq
->ifr_addr
.sa_family
!= AF_INET
)
3557 memcpy (namebuf
, ifq
->ifr_name
, sizeof (ifq
->ifr_name
));
3558 namebuf
[sizeof (ifq
->ifr_name
)] = 0;
3559 res
= Fcons (Fcons (build_string (namebuf
),
3560 conv_sockaddr_to_lisp (&ifq
->ifr_addr
,
3561 sizeof (struct sockaddr
))),
3568 #endif /* SIOCGIFCONF */
3570 #if defined (SIOCGIFADDR) || defined (SIOCGIFHWADDR) || defined (SIOCGIFFLAGS)
3574 const char *flag_sym
;
3577 static const struct ifflag_def ifflag_table
[] = {
3581 #ifdef IFF_BROADCAST
3582 { IFF_BROADCAST
, "broadcast" },
3585 { IFF_DEBUG
, "debug" },
3588 { IFF_LOOPBACK
, "loopback" },
3590 #ifdef IFF_POINTOPOINT
3591 { IFF_POINTOPOINT
, "pointopoint" },
3594 { IFF_RUNNING
, "running" },
3597 { IFF_NOARP
, "noarp" },
3600 { IFF_PROMISC
, "promisc" },
3602 #ifdef IFF_NOTRAILERS
3603 #ifdef NS_IMPL_COCOA
3604 /* Really means smart, notrailers is obsolete */
3605 { IFF_NOTRAILERS
, "smart" },
3607 { IFF_NOTRAILERS
, "notrailers" },
3611 { IFF_ALLMULTI
, "allmulti" },
3614 { IFF_MASTER
, "master" },
3617 { IFF_SLAVE
, "slave" },
3619 #ifdef IFF_MULTICAST
3620 { IFF_MULTICAST
, "multicast" },
3623 { IFF_PORTSEL
, "portsel" },
3625 #ifdef IFF_AUTOMEDIA
3626 { IFF_AUTOMEDIA
, "automedia" },
3629 { IFF_DYNAMIC
, "dynamic" },
3632 { IFF_OACTIVE
, "oactive" }, /* OpenBSD: transmission in progress */
3635 { IFF_SIMPLEX
, "simplex" }, /* OpenBSD: can't hear own transmissions */
3638 { IFF_LINK0
, "link0" }, /* OpenBSD: per link layer defined bit */
3641 { IFF_LINK1
, "link1" }, /* OpenBSD: per link layer defined bit */
3644 { IFF_LINK2
, "link2" }, /* OpenBSD: per link layer defined bit */
3649 DEFUN ("network-interface-info", Fnetwork_interface_info
, Snetwork_interface_info
, 1, 1, 0,
3650 doc
: /* Return information about network interface named IFNAME.
3651 The return value is a list (ADDR BCAST NETMASK HWADDR FLAGS),
3652 where ADDR is the layer 3 address, BCAST is the layer 3 broadcast address,
3653 NETMASK is the layer 3 network mask, HWADDR is the layer 2 address, and
3654 FLAGS is the current flags of the interface. */)
3655 (Lisp_Object ifname
)
3658 Lisp_Object res
= Qnil
;
3662 #if (! (defined SIOCGIFHWADDR && defined HAVE_STRUCT_IFREQ_IFR_HWADDR) \
3663 && defined HAVE_GETIFADDRS && defined LLADDR)
3664 struct ifaddrs
*ifap
;
3667 CHECK_STRING (ifname
);
3669 if (sizeof rq
.ifr_name
<= SBYTES (ifname
))
3670 error ("interface name too long");
3671 strcpy (rq
.ifr_name
, SSDATA (ifname
));
3673 s
= socket (AF_INET
, SOCK_STREAM
, 0);
3678 #if defined (SIOCGIFFLAGS) && defined (HAVE_STRUCT_IFREQ_IFR_FLAGS)
3679 if (ioctl (s
, SIOCGIFFLAGS
, &rq
) == 0)
3681 int flags
= rq
.ifr_flags
;
3682 const struct ifflag_def
*fp
;
3685 /* If flags is smaller than int (i.e. short) it may have the high bit set
3686 due to IFF_MULTICAST. In that case, sign extending it into
3688 if (flags
< 0 && sizeof (rq
.ifr_flags
) < sizeof (flags
))
3689 flags
= (unsigned short) rq
.ifr_flags
;
3692 for (fp
= ifflag_table
; flags
!= 0 && fp
->flag_sym
; fp
++)
3694 if (flags
& fp
->flag_bit
)
3696 elt
= Fcons (intern (fp
->flag_sym
), elt
);
3697 flags
-= fp
->flag_bit
;
3700 for (fnum
= 0; flags
&& fnum
< 32; flags
>>= 1, fnum
++)
3704 elt
= Fcons (make_number (fnum
), elt
);
3709 res
= Fcons (elt
, res
);
3712 #if defined (SIOCGIFHWADDR) && defined (HAVE_STRUCT_IFREQ_IFR_HWADDR)
3713 if (ioctl (s
, SIOCGIFHWADDR
, &rq
) == 0)
3715 Lisp_Object hwaddr
= Fmake_vector (make_number (6), Qnil
);
3716 register struct Lisp_Vector
*p
= XVECTOR (hwaddr
);
3720 for (n
= 0; n
< 6; n
++)
3721 p
->contents
[n
] = make_number (((unsigned char *)&rq
.ifr_hwaddr
.sa_data
[0])[n
]);
3722 elt
= Fcons (make_number (rq
.ifr_hwaddr
.sa_family
), hwaddr
);
3724 #elif defined (HAVE_GETIFADDRS) && defined (LLADDR)
3725 if (getifaddrs (&ifap
) != -1)
3727 Lisp_Object hwaddr
= Fmake_vector (make_number (6), Qnil
);
3728 register struct Lisp_Vector
*p
= XVECTOR (hwaddr
);
3731 for (it
= ifap
; it
!= NULL
; it
= it
->ifa_next
)
3733 struct sockaddr_dl
*sdl
= (struct sockaddr_dl
*) it
->ifa_addr
;
3734 unsigned char linkaddr
[6];
3737 if (it
->ifa_addr
->sa_family
!= AF_LINK
3738 || strcmp (it
->ifa_name
, SSDATA (ifname
)) != 0
3739 || sdl
->sdl_alen
!= 6)
3742 memcpy (linkaddr
, LLADDR (sdl
), sdl
->sdl_alen
);
3743 for (n
= 0; n
< 6; n
++)
3744 p
->contents
[n
] = make_number (linkaddr
[n
]);
3746 elt
= Fcons (make_number (it
->ifa_addr
->sa_family
), hwaddr
);
3750 #ifdef HAVE_FREEIFADDRS
3754 #endif /* HAVE_GETIFADDRS && LLADDR */
3756 res
= Fcons (elt
, res
);
3759 #if defined (SIOCGIFNETMASK) && (defined (HAVE_STRUCT_IFREQ_IFR_NETMASK) || defined (HAVE_STRUCT_IFREQ_IFR_ADDR))
3760 if (ioctl (s
, SIOCGIFNETMASK
, &rq
) == 0)
3763 #ifdef HAVE_STRUCT_IFREQ_IFR_NETMASK
3764 elt
= conv_sockaddr_to_lisp (&rq
.ifr_netmask
, sizeof (rq
.ifr_netmask
));
3766 elt
= conv_sockaddr_to_lisp (&rq
.ifr_addr
, sizeof (rq
.ifr_addr
));
3770 res
= Fcons (elt
, res
);
3773 #if defined (SIOCGIFBRDADDR) && defined (HAVE_STRUCT_IFREQ_IFR_BROADADDR)
3774 if (ioctl (s
, SIOCGIFBRDADDR
, &rq
) == 0)
3777 elt
= conv_sockaddr_to_lisp (&rq
.ifr_broadaddr
, sizeof (rq
.ifr_broadaddr
));
3780 res
= Fcons (elt
, res
);
3783 #if defined (SIOCGIFADDR) && defined (HAVE_STRUCT_IFREQ_IFR_ADDR)
3784 if (ioctl (s
, SIOCGIFADDR
, &rq
) == 0)
3787 elt
= conv_sockaddr_to_lisp (&rq
.ifr_addr
, sizeof (rq
.ifr_addr
));
3790 res
= Fcons (elt
, res
);
3794 return any
? res
: Qnil
;
3797 #endif /* defined (HAVE_NET_IF_H) */
3799 /* Turn off input and output for process PROC. */
3802 deactivate_process (Lisp_Object proc
)
3804 register int inchannel
, outchannel
;
3805 register struct Lisp_Process
*p
= XPROCESS (proc
);
3808 /* Delete GnuTLS structures in PROC, if any. */
3809 emacs_gnutls_deinit (proc
);
3810 #endif /* HAVE_GNUTLS */
3812 inchannel
= p
->infd
;
3813 outchannel
= p
->outfd
;
3815 #ifdef ADAPTIVE_READ_BUFFERING
3816 if (p
->read_output_delay
> 0)
3818 if (--process_output_delay_count
< 0)
3819 process_output_delay_count
= 0;
3820 p
->read_output_delay
= 0;
3821 p
->read_output_skip
= 0;
3827 /* Beware SIGCHLD hereabouts. */
3828 flush_pending_output (inchannel
);
3829 emacs_close (inchannel
);
3830 if (outchannel
>= 0 && outchannel
!= inchannel
)
3831 emacs_close (outchannel
);
3835 #ifdef DATAGRAM_SOCKETS
3836 if (DATAGRAM_CHAN_P (inchannel
))
3838 xfree (datagram_address
[inchannel
].sa
);
3839 datagram_address
[inchannel
].sa
= 0;
3840 datagram_address
[inchannel
].len
= 0;
3843 chan_process
[inchannel
] = Qnil
;
3844 FD_CLR (inchannel
, &input_wait_mask
);
3845 FD_CLR (inchannel
, &non_keyboard_wait_mask
);
3846 #ifdef NON_BLOCKING_CONNECT
3847 if (FD_ISSET (inchannel
, &connect_wait_mask
))
3849 FD_CLR (inchannel
, &connect_wait_mask
);
3850 FD_CLR (inchannel
, &write_mask
);
3851 if (--num_pending_connects
< 0)
3855 if (inchannel
== max_process_desc
)
3858 /* We just closed the highest-numbered process input descriptor,
3859 so recompute the highest-numbered one now. */
3860 max_process_desc
= 0;
3861 for (i
= 0; i
< MAXDESC
; i
++)
3862 if (!NILP (chan_process
[i
]))
3863 max_process_desc
= i
;
3869 DEFUN ("accept-process-output", Faccept_process_output
, Saccept_process_output
,
3871 doc
: /* Allow any pending output from subprocesses to be read by Emacs.
3872 It is read into the process' buffers or given to their filter functions.
3873 Non-nil arg PROCESS means do not return until some output has been received
3876 Non-nil second arg SECONDS and third arg MILLISEC are number of seconds
3877 and milliseconds to wait; return after that much time whether or not
3878 there is any subprocess output. If SECONDS is a floating point number,
3879 it specifies a fractional number of seconds to wait.
3880 The MILLISEC argument is obsolete and should be avoided.
3882 If optional fourth arg JUST-THIS-ONE is non-nil, only accept output
3883 from PROCESS, suspending reading output from other processes.
3884 If JUST-THIS-ONE is an integer, don't run any timers either.
3885 Return non-nil if we received any output before the timeout expired. */)
3886 (register Lisp_Object process
, Lisp_Object seconds
, Lisp_Object millisec
, Lisp_Object just_this_one
)
3891 if (! NILP (process
))
3892 CHECK_PROCESS (process
);
3894 just_this_one
= Qnil
;
3896 if (!NILP (millisec
))
3897 { /* Obsolete calling convention using integers rather than floats. */
3898 CHECK_NUMBER (millisec
);
3900 seconds
= make_float (XINT (millisec
) / 1000.0);
3903 CHECK_NUMBER (seconds
);
3904 seconds
= make_float (XINT (millisec
) / 1000.0 + XINT (seconds
));
3911 if (!NILP (seconds
))
3913 if (INTEGERP (seconds
))
3915 if (0 < XINT (seconds
))
3917 secs
= XINT (seconds
);
3921 else if (FLOATP (seconds
))
3923 if (0 < XFLOAT_DATA (seconds
))
3925 EMACS_TIME t
= EMACS_TIME_FROM_DOUBLE (XFLOAT_DATA (seconds
));
3926 secs
= min (EMACS_SECS (t
), WAIT_READING_MAX
);
3927 nsecs
= EMACS_NSECS (t
);
3931 wrong_type_argument (Qnumberp
, seconds
);
3933 else if (! NILP (process
))
3937 (wait_reading_process_output (secs
, nsecs
, 0, 0,
3939 !NILP (process
) ? XPROCESS (process
) : NULL
,
3940 NILP (just_this_one
) ? 0 :
3941 !INTEGERP (just_this_one
) ? 1 : -1)
3945 /* Accept a connection for server process SERVER on CHANNEL. */
3947 static int connect_counter
= 0;
3950 server_accept_connection (Lisp_Object server
, int channel
)
3952 Lisp_Object proc
, caller
, name
, buffer
;
3953 Lisp_Object contact
, host
, service
;
3954 struct Lisp_Process
*ps
= XPROCESS (server
);
3955 struct Lisp_Process
*p
;
3959 struct sockaddr_in in
;
3961 struct sockaddr_in6 in6
;
3963 #ifdef HAVE_LOCAL_SOCKETS
3964 struct sockaddr_un un
;
3967 socklen_t len
= sizeof saddr
;
3969 s
= accept (channel
, &saddr
.sa
, &len
);
3978 if (code
== EWOULDBLOCK
)
3982 if (!NILP (ps
->log
))
3983 call3 (ps
->log
, server
, Qnil
,
3984 concat3 (build_string ("accept failed with code"),
3985 Fnumber_to_string (make_number (code
)),
3986 build_string ("\n")));
3992 /* Setup a new process to handle the connection. */
3994 /* Generate a unique identification of the caller, and build contact
3995 information for this process. */
3998 switch (saddr
.sa
.sa_family
)
4002 Lisp_Object args
[5];
4003 unsigned char *ip
= (unsigned char *)&saddr
.in
.sin_addr
.s_addr
;
4004 args
[0] = build_string ("%d.%d.%d.%d");
4005 args
[1] = make_number (*ip
++);
4006 args
[2] = make_number (*ip
++);
4007 args
[3] = make_number (*ip
++);
4008 args
[4] = make_number (*ip
++);
4009 host
= Fformat (5, args
);
4010 service
= make_number (ntohs (saddr
.in
.sin_port
));
4012 args
[0] = build_string (" <%s:%d>");
4015 caller
= Fformat (3, args
);
4022 Lisp_Object args
[9];
4023 uint16_t *ip6
= (uint16_t *)&saddr
.in6
.sin6_addr
;
4025 args
[0] = build_string ("%x:%x:%x:%x:%x:%x:%x:%x");
4026 for (i
= 0; i
< 8; i
++)
4027 args
[i
+1] = make_number (ntohs (ip6
[i
]));
4028 host
= Fformat (9, args
);
4029 service
= make_number (ntohs (saddr
.in
.sin_port
));
4031 args
[0] = build_string (" <[%s]:%d>");
4034 caller
= Fformat (3, args
);
4039 #ifdef HAVE_LOCAL_SOCKETS
4043 caller
= Fnumber_to_string (make_number (connect_counter
));
4044 caller
= concat3 (build_string (" <"), caller
, build_string (">"));
4048 /* Create a new buffer name for this process if it doesn't have a
4049 filter. The new buffer name is based on the buffer name or
4050 process name of the server process concatenated with the caller
4053 if (!NILP (ps
->filter
) && !EQ (ps
->filter
, Qt
))
4057 buffer
= ps
->buffer
;
4059 buffer
= Fbuffer_name (buffer
);
4064 buffer
= concat2 (buffer
, caller
);
4065 buffer
= Fget_buffer_create (buffer
);
4069 /* Generate a unique name for the new server process. Combine the
4070 server process name with the caller identification. */
4072 name
= concat2 (ps
->name
, caller
);
4073 proc
= make_process (name
);
4075 chan_process
[s
] = proc
;
4077 fcntl (s
, F_SETFL
, O_NONBLOCK
);
4079 p
= XPROCESS (proc
);
4081 /* Build new contact information for this setup. */
4082 contact
= Fcopy_sequence (ps
->childp
);
4083 contact
= Fplist_put (contact
, QCserver
, Qnil
);
4084 contact
= Fplist_put (contact
, QChost
, host
);
4085 if (!NILP (service
))
4086 contact
= Fplist_put (contact
, QCservice
, service
);
4087 contact
= Fplist_put (contact
, QCremote
,
4088 conv_sockaddr_to_lisp (&saddr
.sa
, len
));
4089 #ifdef HAVE_GETSOCKNAME
4091 if (getsockname (s
, &saddr
.sa
, &len
) == 0)
4092 contact
= Fplist_put (contact
, QClocal
,
4093 conv_sockaddr_to_lisp (&saddr
.sa
, len
));
4096 pset_childp (p
, contact
);
4097 pset_plist (p
, Fcopy_sequence (ps
->plist
));
4098 pset_type (p
, Qnetwork
);
4100 pset_buffer (p
, buffer
);
4101 pset_sentinel (p
, ps
->sentinel
);
4102 pset_filter (p
, ps
->filter
);
4103 pset_command (p
, Qnil
);
4107 pset_status (p
, Qrun
);
4109 /* Client processes for accepted connections are not stopped initially. */
4110 if (!EQ (p
->filter
, Qt
))
4112 FD_SET (s
, &input_wait_mask
);
4113 FD_SET (s
, &non_keyboard_wait_mask
);
4116 if (s
> max_process_desc
)
4117 max_process_desc
= s
;
4119 /* Setup coding system for new process based on server process.
4120 This seems to be the proper thing to do, as the coding system
4121 of the new process should reflect the settings at the time the
4122 server socket was opened; not the current settings. */
4124 pset_decode_coding_system (p
, ps
->decode_coding_system
);
4125 pset_encode_coding_system (p
, ps
->encode_coding_system
);
4126 setup_process_coding_systems (proc
);
4128 pset_decoding_buf (p
, empty_unibyte_string
);
4129 p
->decoding_carryover
= 0;
4130 pset_encoding_buf (p
, empty_unibyte_string
);
4132 p
->inherit_coding_system_flag
4133 = (NILP (buffer
) ? 0 : ps
->inherit_coding_system_flag
);
4135 if (!NILP (ps
->log
))
4136 call3 (ps
->log
, server
, proc
,
4137 concat3 (build_string ("accept from "),
4138 (STRINGP (host
) ? host
: build_string ("-")),
4139 build_string ("\n")));
4141 if (!NILP (p
->sentinel
))
4142 exec_sentinel (proc
,
4143 concat3 (build_string ("open from "),
4144 (STRINGP (host
) ? host
: build_string ("-")),
4145 build_string ("\n")));
4148 /* This variable is different from waiting_for_input in keyboard.c.
4149 It is used to communicate to a lisp process-filter/sentinel (via the
4150 function Fwaiting_for_user_input_p below) whether Emacs was waiting
4151 for user-input when that process-filter was called.
4152 waiting_for_input cannot be used as that is by definition 0 when
4153 lisp code is being evalled.
4154 This is also used in record_asynch_buffer_change.
4155 For that purpose, this must be 0
4156 when not inside wait_reading_process_output. */
4157 static int waiting_for_user_input_p
;
4160 wait_reading_process_output_unwind (Lisp_Object data
)
4162 waiting_for_user_input_p
= XINT (data
);
4166 /* This is here so breakpoints can be put on it. */
4168 wait_reading_process_output_1 (void)
4172 /* Read and dispose of subprocess output while waiting for timeout to
4173 elapse and/or keyboard input to be available.
4177 If negative, gobble data immediately available but don't wait for any.
4180 an additional duration to wait, measured in nanoseconds
4181 If TIME_LIMIT is zero, then:
4182 If NSECS == 0, there is no limit.
4183 If NSECS > 0, the timeout consists of NSECS only.
4184 If NSECS < 0, gobble data immediately, as if TIME_LIMIT were negative.
4187 0 to ignore keyboard input, or
4188 1 to return when input is available, or
4189 -1 meaning caller will actually read the input, so don't throw to
4190 the quit handler, or
4192 DO_DISPLAY means redisplay should be done to show subprocess
4193 output that arrives.
4195 If WAIT_FOR_CELL is a cons cell, wait until its car is non-nil
4196 (and gobble terminal input into the buffer if any arrives).
4198 If WAIT_PROC is specified, wait until something arrives from that
4199 process. The return value is true if we read some input from
4202 If JUST_WAIT_PROC is non-nil, handle only output from WAIT_PROC
4203 (suspending output from other processes). A negative value
4204 means don't run any timers either.
4206 If WAIT_PROC is specified, then the function returns true if we
4207 received input from that process before the timeout elapsed.
4208 Otherwise, return true if we received input from any process. */
4211 wait_reading_process_output (intmax_t time_limit
, int nsecs
, int read_kbd
,
4213 Lisp_Object wait_for_cell
,
4214 struct Lisp_Process
*wait_proc
, int just_wait_proc
)
4216 register int channel
, nfds
;
4217 SELECT_TYPE Available
;
4218 SELECT_TYPE Writeok
;
4220 int check_delay
, no_avail
;
4223 EMACS_TIME timeout
, end_time
;
4224 int wait_channel
= -1;
4225 int got_some_input
= 0;
4226 ptrdiff_t count
= SPECPDL_INDEX ();
4228 FD_ZERO (&Available
);
4231 if (time_limit
== 0 && nsecs
== 0 && wait_proc
&& !NILP (Vinhibit_quit
)
4232 && !(CONSP (wait_proc
->status
)
4233 && EQ (XCAR (wait_proc
->status
), Qexit
)))
4234 message ("Blocking call to accept-process-output with quit inhibited!!");
4236 /* If wait_proc is a process to watch, set wait_channel accordingly. */
4237 if (wait_proc
!= NULL
)
4238 wait_channel
= wait_proc
->infd
;
4240 record_unwind_protect (wait_reading_process_output_unwind
,
4241 make_number (waiting_for_user_input_p
));
4242 waiting_for_user_input_p
= read_kbd
;
4249 else if (TYPE_MAXIMUM (time_t) < time_limit
)
4250 time_limit
= TYPE_MAXIMUM (time_t);
4252 /* Since we may need to wait several times,
4253 compute the absolute time to return at. */
4254 if (time_limit
|| 0 < nsecs
)
4256 timeout
= make_emacs_time (time_limit
, nsecs
);
4257 end_time
= add_emacs_time (current_emacs_time (), timeout
);
4262 int timeout_reduced_for_timers
= 0;
4264 /* If calling from keyboard input, do not quit
4265 since we want to return C-g as an input character.
4266 Otherwise, do pending quit if requested. */
4269 else if (pending_signals
)
4270 process_pending_signals ();
4272 /* Exit now if the cell we're waiting for became non-nil. */
4273 if (! NILP (wait_for_cell
) && ! NILP (XCAR (wait_for_cell
)))
4276 /* Compute time from now till when time limit is up */
4277 /* Exit if already run out */
4280 /* A negative timeout means
4281 gobble output available now
4282 but don't wait at all. */
4284 timeout
= make_emacs_time (0, 0);
4286 else if (time_limit
|| 0 < nsecs
)
4288 EMACS_TIME now
= current_emacs_time ();
4289 if (EMACS_TIME_LE (end_time
, now
))
4291 timeout
= sub_emacs_time (end_time
, now
);
4295 timeout
= make_emacs_time (100000, 0);
4298 /* Normally we run timers here.
4299 But not if wait_for_cell; in those cases,
4300 the wait is supposed to be short,
4301 and those callers cannot handle running arbitrary Lisp code here. */
4302 if (NILP (wait_for_cell
)
4303 && just_wait_proc
>= 0)
4305 EMACS_TIME timer_delay
;
4309 unsigned old_timers_run
= timers_run
;
4310 struct buffer
*old_buffer
= current_buffer
;
4311 Lisp_Object old_window
= selected_window
;
4313 timer_delay
= timer_check ();
4315 /* If a timer has run, this might have changed buffers
4316 an alike. Make read_key_sequence aware of that. */
4317 if (timers_run
!= old_timers_run
4318 && (old_buffer
!= current_buffer
4319 || !EQ (old_window
, selected_window
))
4320 && waiting_for_user_input_p
== -1)
4321 record_asynch_buffer_change ();
4323 if (timers_run
!= old_timers_run
&& do_display
)
4324 /* We must retry, since a timer may have requeued itself
4325 and that could alter the time_delay. */
4326 redisplay_preserve_echo_area (9);
4330 while (!detect_input_pending ());
4332 /* If there is unread keyboard input, also return. */
4334 && requeued_events_pending_p ())
4337 /* A negative timeout means do not wait at all. */
4340 if (EMACS_TIME_VALID_P (timer_delay
))
4342 if (EMACS_TIME_LT (timer_delay
, timeout
))
4344 timeout
= timer_delay
;
4345 timeout_reduced_for_timers
= 1;
4350 /* This is so a breakpoint can be put here. */
4351 wait_reading_process_output_1 ();
4356 /* Cause C-g and alarm signals to take immediate action,
4357 and cause input available signals to zero out timeout.
4359 It is important that we do this before checking for process
4360 activity. If we get a SIGCHLD after the explicit checks for
4361 process activity, timeout is the only way we will know. */
4363 set_waiting_for_input (&timeout
);
4365 /* If status of something has changed, and no input is
4366 available, notify the user of the change right away. After
4367 this explicit check, we'll let the SIGCHLD handler zap
4368 timeout to get our attention. */
4369 if (update_tick
!= process_tick
)
4374 if (kbd_on_hold_p ())
4377 Atemp
= input_wait_mask
;
4380 timeout
= make_emacs_time (0, 0);
4381 if ((pselect (max (max_process_desc
, max_input_desc
) + 1,
4383 #ifdef NON_BLOCKING_CONNECT
4384 (num_pending_connects
> 0 ? &Ctemp
: NULL
),
4388 NULL
, &timeout
, NULL
)
4391 /* It's okay for us to do this and then continue with
4392 the loop, since timeout has already been zeroed out. */
4393 clear_waiting_for_input ();
4394 status_notify (NULL
);
4395 if (do_display
) redisplay_preserve_echo_area (13);
4399 /* Don't wait for output from a non-running process. Just
4400 read whatever data has already been received. */
4401 if (wait_proc
&& wait_proc
->raw_status_new
)
4402 update_status (wait_proc
);
4404 && ! EQ (wait_proc
->status
, Qrun
)
4405 && ! EQ (wait_proc
->status
, Qconnect
))
4407 int nread
, total_nread
= 0;
4409 clear_waiting_for_input ();
4410 XSETPROCESS (proc
, wait_proc
);
4412 /* Read data from the process, until we exhaust it. */
4413 while (wait_proc
->infd
>= 0)
4415 nread
= read_process_output (proc
, wait_proc
->infd
);
4422 total_nread
+= nread
;
4425 else if (nread
== -1 && (errno
== EIO
|| errno
== EAGAIN
))
4428 else if (nread
== -1 && EWOULDBLOCK
== errno
)
4432 if (total_nread
> 0 && do_display
)
4433 redisplay_preserve_echo_area (10);
4438 /* Wait till there is something to do */
4440 if (wait_proc
&& just_wait_proc
)
4442 if (wait_proc
->infd
< 0) /* Terminated */
4444 FD_SET (wait_proc
->infd
, &Available
);
4448 else if (!NILP (wait_for_cell
))
4450 Available
= non_process_wait_mask
;
4457 Available
= non_keyboard_wait_mask
;
4459 Available
= input_wait_mask
;
4460 Writeok
= write_mask
;
4461 #ifdef SELECT_CANT_DO_WRITE_MASK
4466 check_delay
= wait_channel
>= 0 ? 0 : process_output_delay_count
;
4469 /* If frame size has changed or the window is newly mapped,
4470 redisplay now, before we start to wait. There is a race
4471 condition here; if a SIGIO arrives between now and the select
4472 and indicates that a frame is trashed, the select may block
4473 displaying a trashed screen. */
4474 if (frame_garbaged
&& do_display
)
4476 clear_waiting_for_input ();
4477 redisplay_preserve_echo_area (11);
4479 set_waiting_for_input (&timeout
);
4482 /* Skip the `select' call if input is available and we're
4483 waiting for keyboard input or a cell change (which can be
4484 triggered by processing X events). In the latter case, set
4485 nfds to 1 to avoid breaking the loop. */
4487 if ((read_kbd
|| !NILP (wait_for_cell
))
4488 && detect_input_pending ())
4490 nfds
= read_kbd
? 0 : 1;
4497 #ifdef ADAPTIVE_READ_BUFFERING
4498 /* Set the timeout for adaptive read buffering if any
4499 process has non-zero read_output_skip and non-zero
4500 read_output_delay, and we are not reading output for a
4501 specific wait_channel. It is not executed if
4502 Vprocess_adaptive_read_buffering is nil. */
4503 if (process_output_skip
&& check_delay
> 0)
4505 int nsecs
= EMACS_NSECS (timeout
);
4506 if (EMACS_SECS (timeout
) > 0 || nsecs
> READ_OUTPUT_DELAY_MAX
)
4507 nsecs
= READ_OUTPUT_DELAY_MAX
;
4508 for (channel
= 0; check_delay
> 0 && channel
<= max_process_desc
; channel
++)
4510 proc
= chan_process
[channel
];
4513 /* Find minimum non-zero read_output_delay among the
4514 processes with non-zero read_output_skip. */
4515 if (XPROCESS (proc
)->read_output_delay
> 0)
4518 if (!XPROCESS (proc
)->read_output_skip
)
4520 FD_CLR (channel
, &Available
);
4521 XPROCESS (proc
)->read_output_skip
= 0;
4522 if (XPROCESS (proc
)->read_output_delay
< nsecs
)
4523 nsecs
= XPROCESS (proc
)->read_output_delay
;
4526 timeout
= make_emacs_time (0, nsecs
);
4527 process_output_skip
= 0;
4531 #if defined (USE_GTK) || defined (HAVE_GCONF) || defined (HAVE_GSETTINGS)
4533 #elif defined (HAVE_NS)
4538 (max (max_process_desc
, max_input_desc
) + 1,
4540 (check_write
? &Writeok
: (SELECT_TYPE
*)0),
4541 NULL
, &timeout
, NULL
);
4544 /* GnuTLS buffers data internally. In lowat mode it leaves
4545 some data in the TCP buffers so that select works, but
4546 with custom pull/push functions we need to check if some
4547 data is available in the buffers manually. */
4552 /* We're not waiting on a specific process, so loop
4553 through all the channels and check for data.
4554 This is a workaround needed for some versions of
4555 the gnutls library -- 2.12.14 has been confirmed
4557 http://comments.gmane.org/gmane.emacs.devel/145074 */
4558 for (channel
= 0; channel
< MAXDESC
; ++channel
)
4559 if (! NILP (chan_process
[channel
]))
4561 struct Lisp_Process
*p
=
4562 XPROCESS (chan_process
[channel
]);
4563 if (p
&& p
->gnutls_p
&& p
->infd
4564 && ((emacs_gnutls_record_check_pending
4569 FD_SET (p
->infd
, &Available
);
4575 /* Check this specific channel. */
4576 if (wait_proc
->gnutls_p
/* Check for valid process. */
4577 /* Do we have pending data? */
4578 && ((emacs_gnutls_record_check_pending
4579 (wait_proc
->gnutls_state
))
4583 /* Set to Available. */
4584 FD_SET (wait_proc
->infd
, &Available
);
4593 /* Make C-g and alarm signals set flags again */
4594 clear_waiting_for_input ();
4596 /* If we woke up due to SIGWINCH, actually change size now. */
4597 do_pending_window_change (0);
4599 if ((time_limit
|| nsecs
) && nfds
== 0 && ! timeout_reduced_for_timers
)
4600 /* We waited the full specified time, so return now. */
4604 if (xerrno
== EINTR
)
4606 else if (xerrno
== EBADF
)
4609 /* AIX doesn't handle PTY closure the same way BSD does. On AIX,
4610 the child's closure of the pts gives the parent a SIGHUP, and
4611 the ptc file descriptor is automatically closed,
4612 yielding EBADF here or at select() call above.
4613 So, SIGHUP is ignored (see def of PTY_TTY_NAME_SPRINTF
4614 in m/ibmrt-aix.h), and here we just ignore the select error.
4615 Cleanup occurs c/o status_notify after SIGCLD. */
4616 no_avail
= 1; /* Cannot depend on values returned */
4622 error ("select error: %s", emacs_strerror (xerrno
));
4627 FD_ZERO (&Available
);
4631 /* Check for keyboard input */
4632 /* If there is any, return immediately
4633 to give it higher priority than subprocesses */
4637 unsigned old_timers_run
= timers_run
;
4638 struct buffer
*old_buffer
= current_buffer
;
4639 Lisp_Object old_window
= selected_window
;
4642 if (detect_input_pending_run_timers (do_display
))
4644 swallow_events (do_display
);
4645 if (detect_input_pending_run_timers (do_display
))
4649 /* If a timer has run, this might have changed buffers
4650 an alike. Make read_key_sequence aware of that. */
4651 if (timers_run
!= old_timers_run
4652 && waiting_for_user_input_p
== -1
4653 && (old_buffer
!= current_buffer
4654 || !EQ (old_window
, selected_window
)))
4655 record_asynch_buffer_change ();
4661 /* If there is unread keyboard input, also return. */
4663 && requeued_events_pending_p ())
4666 /* If we are not checking for keyboard input now,
4667 do process events (but don't run any timers).
4668 This is so that X events will be processed.
4669 Otherwise they may have to wait until polling takes place.
4670 That would causes delays in pasting selections, for example.
4672 (We used to do this only if wait_for_cell.) */
4673 if (read_kbd
== 0 && detect_input_pending ())
4675 swallow_events (do_display
);
4676 #if 0 /* Exiting when read_kbd doesn't request that seems wrong, though. */
4677 if (detect_input_pending ())
4682 /* Exit now if the cell we're waiting for became non-nil. */
4683 if (! NILP (wait_for_cell
) && ! NILP (XCAR (wait_for_cell
)))
4687 /* If we think we have keyboard input waiting, but didn't get SIGIO,
4688 go read it. This can happen with X on BSD after logging out.
4689 In that case, there really is no input and no SIGIO,
4690 but select says there is input. */
4692 if (read_kbd
&& interrupt_input
4693 && keyboard_bit_set (&Available
) && ! noninteractive
)
4694 handle_input_available_signal (SIGIO
);
4698 got_some_input
|= nfds
> 0;
4700 /* If checking input just got us a size-change event from X,
4701 obey it now if we should. */
4702 if (read_kbd
|| ! NILP (wait_for_cell
))
4703 do_pending_window_change (0);
4705 /* Check for data from a process. */
4706 if (no_avail
|| nfds
== 0)
4709 for (channel
= 0; channel
<= max_input_desc
; ++channel
)
4711 struct fd_callback_data
*d
= &fd_callback_info
[channel
];
4713 && ((d
->condition
& FOR_READ
4714 && FD_ISSET (channel
, &Available
))
4715 || (d
->condition
& FOR_WRITE
4716 && FD_ISSET (channel
, &write_mask
))))
4717 d
->func (channel
, d
->data
);
4720 for (channel
= 0; channel
<= max_process_desc
; channel
++)
4722 if (FD_ISSET (channel
, &Available
)
4723 && FD_ISSET (channel
, &non_keyboard_wait_mask
)
4724 && !FD_ISSET (channel
, &non_process_wait_mask
))
4728 /* If waiting for this channel, arrange to return as
4729 soon as no more input to be processed. No more
4731 if (wait_channel
== channel
)
4737 proc
= chan_process
[channel
];
4741 /* If this is a server stream socket, accept connection. */
4742 if (EQ (XPROCESS (proc
)->status
, Qlisten
))
4744 server_accept_connection (proc
, channel
);
4748 /* Read data from the process, starting with our
4749 buffered-ahead character if we have one. */
4751 nread
= read_process_output (proc
, channel
);
4754 /* Since read_process_output can run a filter,
4755 which can call accept-process-output,
4756 don't try to read from any other processes
4757 before doing the select again. */
4758 FD_ZERO (&Available
);
4761 redisplay_preserve_echo_area (12);
4764 else if (nread
== -1 && errno
== EWOULDBLOCK
)
4767 else if (nread
== -1 && errno
== EAGAIN
)
4770 /* FIXME: Is this special case still needed? */
4771 /* Note that we cannot distinguish between no input
4772 available now and a closed pipe.
4773 With luck, a closed pipe will be accompanied by
4774 subprocess termination and SIGCHLD. */
4775 else if (nread
== 0 && !NETCONN_P (proc
) && !SERIALCONN_P (proc
))
4779 /* On some OSs with ptys, when the process on one end of
4780 a pty exits, the other end gets an error reading with
4781 errno = EIO instead of getting an EOF (0 bytes read).
4782 Therefore, if we get an error reading and errno =
4783 EIO, just continue, because the child process has
4784 exited and should clean itself up soon (e.g. when we
4787 However, it has been known to happen that the SIGCHLD
4788 got lost. So raise the signal again just in case.
4790 else if (nread
== -1 && errno
== EIO
)
4792 struct Lisp_Process
*p
= XPROCESS (proc
);
4794 /* Clear the descriptor now, so we only raise the
4796 FD_CLR (channel
, &input_wait_mask
);
4797 FD_CLR (channel
, &non_keyboard_wait_mask
);
4801 /* If the EIO occurs on a pty, the SIGCHLD handler's
4802 waitpid call will not find the process object to
4803 delete. Do it here. */
4804 p
->tick
= ++process_tick
;
4805 pset_status (p
, Qfailed
);
4808 handle_child_signal (SIGCHLD
);
4810 #endif /* HAVE_PTYS */
4811 /* If we can detect process termination, don't consider the
4812 process gone just because its pipe is closed. */
4814 else if (nread
== 0 && !NETCONN_P (proc
) && !SERIALCONN_P (proc
))
4819 /* Preserve status of processes already terminated. */
4820 XPROCESS (proc
)->tick
= ++process_tick
;
4821 deactivate_process (proc
);
4822 if (XPROCESS (proc
)->raw_status_new
)
4823 update_status (XPROCESS (proc
));
4824 if (EQ (XPROCESS (proc
)->status
, Qrun
))
4825 pset_status (XPROCESS (proc
),
4826 list2 (Qexit
, make_number (256)));
4829 #ifdef NON_BLOCKING_CONNECT
4830 if (FD_ISSET (channel
, &Writeok
)
4831 && FD_ISSET (channel
, &connect_wait_mask
))
4833 struct Lisp_Process
*p
;
4835 FD_CLR (channel
, &connect_wait_mask
);
4836 FD_CLR (channel
, &write_mask
);
4837 if (--num_pending_connects
< 0)
4840 proc
= chan_process
[channel
];
4844 p
= XPROCESS (proc
);
4847 /* getsockopt(,,SO_ERROR,,) is said to hang on some systems.
4848 So only use it on systems where it is known to work. */
4850 socklen_t xlen
= sizeof (xerrno
);
4851 if (getsockopt (channel
, SOL_SOCKET
, SO_ERROR
, &xerrno
, &xlen
))
4856 struct sockaddr pname
;
4857 int pnamelen
= sizeof (pname
);
4859 /* If connection failed, getpeername will fail. */
4861 if (getpeername (channel
, &pname
, &pnamelen
) < 0)
4863 /* Obtain connect failure code through error slippage. */
4866 if (errno
== ENOTCONN
&& read (channel
, &dummy
, 1) < 0)
4873 p
->tick
= ++process_tick
;
4874 pset_status (p
, list2 (Qfailed
, make_number (xerrno
)));
4875 deactivate_process (proc
);
4879 pset_status (p
, Qrun
);
4880 /* Execute the sentinel here. If we had relied on
4881 status_notify to do it later, it will read input
4882 from the process before calling the sentinel. */
4883 exec_sentinel (proc
, build_string ("open\n"));
4884 if (!EQ (p
->filter
, Qt
) && !EQ (p
->command
, Qt
))
4886 FD_SET (p
->infd
, &input_wait_mask
);
4887 FD_SET (p
->infd
, &non_keyboard_wait_mask
);
4891 #endif /* NON_BLOCKING_CONNECT */
4892 } /* end for each file descriptor */
4893 } /* end while exit conditions not met */
4895 unbind_to (count
, Qnil
);
4897 /* If calling from keyboard input, do not quit
4898 since we want to return C-g as an input character.
4899 Otherwise, do pending quit if requested. */
4902 /* Prevent input_pending from remaining set if we quit. */
4903 clear_input_pending ();
4907 return got_some_input
;
4910 /* Given a list (FUNCTION ARGS...), apply FUNCTION to the ARGS. */
4913 read_process_output_call (Lisp_Object fun_and_args
)
4915 return apply1 (XCAR (fun_and_args
), XCDR (fun_and_args
));
4919 read_process_output_error_handler (Lisp_Object error_val
)
4921 cmd_error_internal (error_val
, "error in process filter: ");
4923 update_echo_area ();
4924 Fsleep_for (make_number (2), Qnil
);
4928 /* Read pending output from the process channel,
4929 starting with our buffered-ahead character if we have one.
4930 Yield number of decoded characters read.
4932 This function reads at most 4096 characters.
4933 If you want to read all available subprocess output,
4934 you must call it repeatedly until it returns zero.
4936 The characters read are decoded according to PROC's coding-system
4940 read_process_output (Lisp_Object proc
, register int channel
)
4942 register ssize_t nbytes
;
4944 register Lisp_Object outstream
;
4945 register struct Lisp_Process
*p
= XPROCESS (proc
);
4946 register ptrdiff_t opoint
;
4947 struct coding_system
*coding
= proc_decode_coding_system
[channel
];
4948 int carryover
= p
->decoding_carryover
;
4950 ptrdiff_t count
= SPECPDL_INDEX ();
4951 Lisp_Object odeactivate
;
4953 chars
= alloca (carryover
+ readmax
);
4955 /* See the comment above. */
4956 memcpy (chars
, SDATA (p
->decoding_buf
), carryover
);
4958 #ifdef DATAGRAM_SOCKETS
4959 /* We have a working select, so proc_buffered_char is always -1. */
4960 if (DATAGRAM_CHAN_P (channel
))
4962 socklen_t len
= datagram_address
[channel
].len
;
4963 nbytes
= recvfrom (channel
, chars
+ carryover
, readmax
,
4964 0, datagram_address
[channel
].sa
, &len
);
4969 int buffered
= 0 <= proc_buffered_char
[channel
];
4972 chars
[carryover
] = proc_buffered_char
[channel
];
4973 proc_buffered_char
[channel
] = -1;
4977 nbytes
= emacs_gnutls_read (p
, chars
+ carryover
+ buffered
,
4978 readmax
- buffered
);
4981 nbytes
= emacs_read (channel
, chars
+ carryover
+ buffered
,
4982 readmax
- buffered
);
4983 #ifdef ADAPTIVE_READ_BUFFERING
4984 if (nbytes
> 0 && p
->adaptive_read_buffering
)
4986 int delay
= p
->read_output_delay
;
4989 if (delay
< READ_OUTPUT_DELAY_MAX_MAX
)
4992 process_output_delay_count
++;
4993 delay
+= READ_OUTPUT_DELAY_INCREMENT
* 2;
4996 else if (delay
> 0 && nbytes
== readmax
- buffered
)
4998 delay
-= READ_OUTPUT_DELAY_INCREMENT
;
5000 process_output_delay_count
--;
5002 p
->read_output_delay
= delay
;
5005 p
->read_output_skip
= 1;
5006 process_output_skip
= 1;
5011 nbytes
+= buffered
&& nbytes
<= 0;
5014 p
->decoding_carryover
= 0;
5016 /* At this point, NBYTES holds number of bytes just received
5017 (including the one in proc_buffered_char[channel]). */
5020 if (nbytes
< 0 || coding
->mode
& CODING_MODE_LAST_BLOCK
)
5022 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
5025 /* Now set NBYTES how many bytes we must decode. */
5026 nbytes
+= carryover
;
5028 odeactivate
= Vdeactivate_mark
;
5029 /* There's no good reason to let process filters change the current
5030 buffer, and many callers of accept-process-output, sit-for, and
5031 friends don't expect current-buffer to be changed from under them. */
5032 record_unwind_current_buffer ();
5034 /* Read and dispose of the process output. */
5035 outstream
= p
->filter
;
5036 if (!NILP (outstream
))
5039 bool outer_running_asynch_code
= running_asynch_code
;
5040 int waiting
= waiting_for_user_input_p
;
5042 /* No need to gcpro these, because all we do with them later
5043 is test them for EQness, and none of them should be a string. */
5045 Lisp_Object obuffer
, okeymap
;
5046 XSETBUFFER (obuffer
, current_buffer
);
5047 okeymap
= BVAR (current_buffer
, keymap
);
5050 /* We inhibit quit here instead of just catching it so that
5051 hitting ^G when a filter happens to be running won't screw
5053 specbind (Qinhibit_quit
, Qt
);
5054 specbind (Qlast_nonmenu_event
, Qt
);
5056 /* In case we get recursively called,
5057 and we already saved the match data nonrecursively,
5058 save the same match data in safely recursive fashion. */
5059 if (outer_running_asynch_code
)
5062 /* Don't clobber the CURRENT match data, either! */
5063 tem
= Fmatch_data (Qnil
, Qnil
, Qnil
);
5064 restore_search_regs ();
5065 record_unwind_save_match_data ();
5066 Fset_match_data (tem
, Qt
);
5069 /* For speed, if a search happens within this code,
5070 save the match data in a special nonrecursive fashion. */
5071 running_asynch_code
= 1;
5073 decode_coding_c_string (coding
, (unsigned char *) chars
, nbytes
, Qt
);
5074 text
= coding
->dst_object
;
5075 Vlast_coding_system_used
= CODING_ID_NAME (coding
->id
);
5076 /* A new coding system might be found. */
5077 if (!EQ (p
->decode_coding_system
, Vlast_coding_system_used
))
5079 pset_decode_coding_system (p
, Vlast_coding_system_used
);
5081 /* Don't call setup_coding_system for
5082 proc_decode_coding_system[channel] here. It is done in
5083 detect_coding called via decode_coding above. */
5085 /* If a coding system for encoding is not yet decided, we set
5086 it as the same as coding-system for decoding.
5088 But, before doing that we must check if
5089 proc_encode_coding_system[p->outfd] surely points to a
5090 valid memory because p->outfd will be changed once EOF is
5091 sent to the process. */
5092 if (NILP (p
->encode_coding_system
)
5093 && proc_encode_coding_system
[p
->outfd
])
5095 pset_encode_coding_system
5096 (p
, coding_inherit_eol_type (Vlast_coding_system_used
, Qnil
));
5097 setup_coding_system (p
->encode_coding_system
,
5098 proc_encode_coding_system
[p
->outfd
]);
5102 if (coding
->carryover_bytes
> 0)
5104 if (SCHARS (p
->decoding_buf
) < coding
->carryover_bytes
)
5105 pset_decoding_buf (p
, make_uninit_string (coding
->carryover_bytes
));
5106 memcpy (SDATA (p
->decoding_buf
), coding
->carryover
,
5107 coding
->carryover_bytes
);
5108 p
->decoding_carryover
= coding
->carryover_bytes
;
5110 if (SBYTES (text
) > 0)
5111 /* FIXME: It's wrong to wrap or not based on debug-on-error, and
5112 sometimes it's simply wrong to wrap (e.g. when called from
5113 accept-process-output). */
5114 internal_condition_case_1 (read_process_output_call
,
5116 Fcons (proc
, Fcons (text
, Qnil
))),
5117 !NILP (Vdebug_on_error
) ? Qnil
: Qerror
,
5118 read_process_output_error_handler
);
5120 /* If we saved the match data nonrecursively, restore it now. */
5121 restore_search_regs ();
5122 running_asynch_code
= outer_running_asynch_code
;
5124 /* Restore waiting_for_user_input_p as it was
5125 when we were called, in case the filter clobbered it. */
5126 waiting_for_user_input_p
= waiting
;
5128 #if 0 /* Call record_asynch_buffer_change unconditionally,
5129 because we might have changed minor modes or other things
5130 that affect key bindings. */
5131 if (! EQ (Fcurrent_buffer (), obuffer
)
5132 || ! EQ (current_buffer
->keymap
, okeymap
))
5134 /* But do it only if the caller is actually going to read events.
5135 Otherwise there's no need to make him wake up, and it could
5136 cause trouble (for example it would make sit_for return). */
5137 if (waiting_for_user_input_p
== -1)
5138 record_asynch_buffer_change ();
5141 /* If no filter, write into buffer if it isn't dead. */
5142 else if (!NILP (p
->buffer
) && BUFFER_LIVE_P (XBUFFER (p
->buffer
)))
5144 Lisp_Object old_read_only
;
5145 ptrdiff_t old_begv
, old_zv
;
5146 ptrdiff_t old_begv_byte
, old_zv_byte
;
5147 ptrdiff_t before
, before_byte
;
5148 ptrdiff_t opoint_byte
;
5152 Fset_buffer (p
->buffer
);
5154 opoint_byte
= PT_BYTE
;
5155 old_read_only
= BVAR (current_buffer
, read_only
);
5158 old_begv_byte
= BEGV_BYTE
;
5159 old_zv_byte
= ZV_BYTE
;
5161 bset_read_only (current_buffer
, Qnil
);
5163 /* Insert new output into buffer
5164 at the current end-of-output marker,
5165 thus preserving logical ordering of input and output. */
5166 if (XMARKER (p
->mark
)->buffer
)
5167 SET_PT_BOTH (clip_to_bounds (BEGV
,
5168 marker_position (p
->mark
), ZV
),
5169 clip_to_bounds (BEGV_BYTE
,
5170 marker_byte_position (p
->mark
),
5173 SET_PT_BOTH (ZV
, ZV_BYTE
);
5175 before_byte
= PT_BYTE
;
5177 /* If the output marker is outside of the visible region, save
5178 the restriction and widen. */
5179 if (! (BEGV
<= PT
&& PT
<= ZV
))
5182 decode_coding_c_string (coding
, (unsigned char *) chars
, nbytes
, Qt
);
5183 text
= coding
->dst_object
;
5184 Vlast_coding_system_used
= CODING_ID_NAME (coding
->id
);
5185 /* A new coding system might be found. See the comment in the
5186 similar code in the previous `if' block. */
5187 if (!EQ (p
->decode_coding_system
, Vlast_coding_system_used
))
5189 pset_decode_coding_system (p
, Vlast_coding_system_used
);
5190 if (NILP (p
->encode_coding_system
)
5191 && proc_encode_coding_system
[p
->outfd
])
5193 pset_encode_coding_system
5194 (p
, coding_inherit_eol_type (Vlast_coding_system_used
, Qnil
));
5195 setup_coding_system (p
->encode_coding_system
,
5196 proc_encode_coding_system
[p
->outfd
]);
5199 if (coding
->carryover_bytes
> 0)
5201 if (SCHARS (p
->decoding_buf
) < coding
->carryover_bytes
)
5202 pset_decoding_buf (p
, make_uninit_string (coding
->carryover_bytes
));
5203 memcpy (SDATA (p
->decoding_buf
), coding
->carryover
,
5204 coding
->carryover_bytes
);
5205 p
->decoding_carryover
= coding
->carryover_bytes
;
5207 /* Adjust the multibyteness of TEXT to that of the buffer. */
5208 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
))
5209 != ! STRING_MULTIBYTE (text
))
5210 text
= (STRING_MULTIBYTE (text
)
5211 ? Fstring_as_unibyte (text
)
5212 : Fstring_to_multibyte (text
));
5213 /* Insert before markers in case we are inserting where
5214 the buffer's mark is, and the user's next command is Meta-y. */
5215 insert_from_string_before_markers (text
, 0, 0,
5216 SCHARS (text
), SBYTES (text
), 0);
5218 /* Make sure the process marker's position is valid when the
5219 process buffer is changed in the signal_after_change above.
5220 W3 is known to do that. */
5221 if (BUFFERP (p
->buffer
)
5222 && (b
= XBUFFER (p
->buffer
), b
!= current_buffer
))
5223 set_marker_both (p
->mark
, p
->buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
5225 set_marker_both (p
->mark
, p
->buffer
, PT
, PT_BYTE
);
5227 update_mode_lines
++;
5229 /* Make sure opoint and the old restrictions
5230 float ahead of any new text just as point would. */
5231 if (opoint
>= before
)
5233 opoint
+= PT
- before
;
5234 opoint_byte
+= PT_BYTE
- before_byte
;
5236 if (old_begv
> before
)
5238 old_begv
+= PT
- before
;
5239 old_begv_byte
+= PT_BYTE
- before_byte
;
5241 if (old_zv
>= before
)
5243 old_zv
+= PT
- before
;
5244 old_zv_byte
+= PT_BYTE
- before_byte
;
5247 /* If the restriction isn't what it should be, set it. */
5248 if (old_begv
!= BEGV
|| old_zv
!= ZV
)
5249 Fnarrow_to_region (make_number (old_begv
), make_number (old_zv
));
5252 bset_read_only (current_buffer
, old_read_only
);
5253 SET_PT_BOTH (opoint
, opoint_byte
);
5255 /* Handling the process output should not deactivate the mark. */
5256 Vdeactivate_mark
= odeactivate
;
5258 unbind_to (count
, Qnil
);
5262 /* Sending data to subprocess */
5264 /* In send_process, when a write fails temporarily,
5265 wait_reading_process_output is called. It may execute user code,
5266 e.g. timers, that attempts to write new data to the same process.
5267 We must ensure that data is sent in the right order, and not
5268 interspersed half-completed with other writes (Bug#10815). This is
5269 handled by the write_queue element of struct process. It is a list
5270 with each entry having the form
5272 (string . (offset . length))
5274 where STRING is a lisp string, OFFSET is the offset into the
5275 string's byte sequence from which we should begin to send, and
5276 LENGTH is the number of bytes left to send. */
5278 /* Create a new entry in write_queue.
5279 INPUT_OBJ should be a buffer, string Qt, or Qnil.
5280 BUF is a pointer to the string sequence of the input_obj or a C
5281 string in case of Qt or Qnil. */
5284 write_queue_push (struct Lisp_Process
*p
, Lisp_Object input_obj
,
5285 const char *buf
, ptrdiff_t len
, int front
)
5288 Lisp_Object entry
, obj
;
5290 if (STRINGP (input_obj
))
5292 offset
= buf
- SSDATA (input_obj
);
5298 obj
= make_unibyte_string (buf
, len
);
5301 entry
= Fcons (obj
, Fcons (make_number (offset
), make_number (len
)));
5304 pset_write_queue (p
, Fcons (entry
, p
->write_queue
));
5306 pset_write_queue (p
, nconc2 (p
->write_queue
, Fcons (entry
, Qnil
)));
5309 /* Remove the first element in the write_queue of process P, put its
5310 contents in OBJ, BUF and LEN, and return non-zero. If the
5311 write_queue is empty, return zero. */
5314 write_queue_pop (struct Lisp_Process
*p
, Lisp_Object
*obj
,
5315 const char **buf
, ptrdiff_t *len
)
5317 Lisp_Object entry
, offset_length
;
5320 if (NILP (p
->write_queue
))
5323 entry
= XCAR (p
->write_queue
);
5324 pset_write_queue (p
, XCDR (p
->write_queue
));
5326 *obj
= XCAR (entry
);
5327 offset_length
= XCDR (entry
);
5329 *len
= XINT (XCDR (offset_length
));
5330 offset
= XINT (XCAR (offset_length
));
5331 *buf
= SSDATA (*obj
) + offset
;
5336 /* Send some data to process PROC.
5337 BUF is the beginning of the data; LEN is the number of characters.
5338 OBJECT is the Lisp object that the data comes from. If OBJECT is
5339 nil or t, it means that the data comes from C string.
5341 If OBJECT is not nil, the data is encoded by PROC's coding-system
5342 for encoding before it is sent.
5344 This function can evaluate Lisp code and can garbage collect. */
5347 send_process (Lisp_Object proc
, const char *buf
, ptrdiff_t len
,
5350 struct Lisp_Process
*p
= XPROCESS (proc
);
5352 struct coding_system
*coding
;
5354 if (p
->raw_status_new
)
5356 if (! EQ (p
->status
, Qrun
))
5357 error ("Process %s not running", SDATA (p
->name
));
5359 error ("Output file descriptor of %s is closed", SDATA (p
->name
));
5361 coding
= proc_encode_coding_system
[p
->outfd
];
5362 Vlast_coding_system_used
= CODING_ID_NAME (coding
->id
);
5364 if ((STRINGP (object
) && STRING_MULTIBYTE (object
))
5365 || (BUFFERP (object
)
5366 && !NILP (BVAR (XBUFFER (object
), enable_multibyte_characters
)))
5369 pset_encode_coding_system
5370 (p
, complement_process_encoding_system (p
->encode_coding_system
));
5371 if (!EQ (Vlast_coding_system_used
, p
->encode_coding_system
))
5373 /* The coding system for encoding was changed to raw-text
5374 because we sent a unibyte text previously. Now we are
5375 sending a multibyte text, thus we must encode it by the
5376 original coding system specified for the current process.
5378 Another reason we come here is that the coding system
5379 was just complemented and a new one was returned by
5380 complement_process_encoding_system. */
5381 setup_coding_system (p
->encode_coding_system
, coding
);
5382 Vlast_coding_system_used
= p
->encode_coding_system
;
5384 coding
->src_multibyte
= 1;
5388 coding
->src_multibyte
= 0;
5389 /* For sending a unibyte text, character code conversion should
5390 not take place but EOL conversion should. So, setup raw-text
5391 or one of the subsidiary if we have not yet done it. */
5392 if (CODING_REQUIRE_ENCODING (coding
))
5394 if (CODING_REQUIRE_FLUSHING (coding
))
5396 /* But, before changing the coding, we must flush out data. */
5397 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
5398 send_process (proc
, "", 0, Qt
);
5399 coding
->mode
&= CODING_MODE_LAST_BLOCK
;
5401 setup_coding_system (raw_text_coding_system
5402 (Vlast_coding_system_used
),
5404 coding
->src_multibyte
= 0;
5407 coding
->dst_multibyte
= 0;
5409 if (CODING_REQUIRE_ENCODING (coding
))
5411 coding
->dst_object
= Qt
;
5412 if (BUFFERP (object
))
5414 ptrdiff_t from_byte
, from
, to
;
5415 ptrdiff_t save_pt
, save_pt_byte
;
5416 struct buffer
*cur
= current_buffer
;
5418 set_buffer_internal (XBUFFER (object
));
5419 save_pt
= PT
, save_pt_byte
= PT_BYTE
;
5421 from_byte
= PTR_BYTE_POS ((unsigned char *) buf
);
5422 from
= BYTE_TO_CHAR (from_byte
);
5423 to
= BYTE_TO_CHAR (from_byte
+ len
);
5424 TEMP_SET_PT_BOTH (from
, from_byte
);
5425 encode_coding_object (coding
, object
, from
, from_byte
,
5426 to
, from_byte
+ len
, Qt
);
5427 TEMP_SET_PT_BOTH (save_pt
, save_pt_byte
);
5428 set_buffer_internal (cur
);
5430 else if (STRINGP (object
))
5432 encode_coding_object (coding
, object
, 0, 0, SCHARS (object
),
5433 SBYTES (object
), Qt
);
5437 coding
->dst_object
= make_unibyte_string (buf
, len
);
5438 coding
->produced
= len
;
5441 len
= coding
->produced
;
5442 object
= coding
->dst_object
;
5443 buf
= SSDATA (object
);
5446 /* If there is already data in the write_queue, put the new data
5447 in the back of queue. Otherwise, ignore it. */
5448 if (!NILP (p
->write_queue
))
5449 write_queue_push (p
, object
, buf
, len
, 0);
5451 do /* while !NILP (p->write_queue) */
5453 ptrdiff_t cur_len
= -1;
5454 const char *cur_buf
;
5455 Lisp_Object cur_object
;
5457 /* If write_queue is empty, ignore it. */
5458 if (!write_queue_pop (p
, &cur_object
, &cur_buf
, &cur_len
))
5462 cur_object
= object
;
5467 /* Send this batch, using one or more write calls. */
5468 ptrdiff_t written
= 0;
5469 int outfd
= p
->outfd
;
5470 #ifdef DATAGRAM_SOCKETS
5471 if (DATAGRAM_CHAN_P (outfd
))
5473 rv
= sendto (outfd
, cur_buf
, cur_len
,
5474 0, datagram_address
[outfd
].sa
,
5475 datagram_address
[outfd
].len
);
5478 else if (errno
== EMSGSIZE
)
5479 report_file_error ("sending datagram", Fcons (proc
, Qnil
));
5486 written
= emacs_gnutls_write (p
, cur_buf
, cur_len
);
5489 written
= emacs_write (outfd
, cur_buf
, cur_len
);
5490 rv
= (written
? 0 : -1);
5491 #ifdef ADAPTIVE_READ_BUFFERING
5492 if (p
->read_output_delay
> 0
5493 && p
->adaptive_read_buffering
== 1)
5495 p
->read_output_delay
= 0;
5496 process_output_delay_count
--;
5497 p
->read_output_skip
= 0;
5506 || errno
== EWOULDBLOCK
5509 /* Buffer is full. Wait, accepting input;
5510 that may allow the program
5511 to finish doing output and read more. */
5513 #ifdef BROKEN_PTY_READ_AFTER_EAGAIN
5514 /* A gross hack to work around a bug in FreeBSD.
5515 In the following sequence, read(2) returns
5519 write(2) 954 bytes, get EAGAIN
5520 read(2) 1024 bytes in process_read_output
5521 read(2) 11 bytes in process_read_output
5523 That is, read(2) returns more bytes than have
5524 ever been written successfully. The 1033 bytes
5525 read are the 1022 bytes written successfully
5526 after processing (for example with CRs added if
5527 the terminal is set up that way which it is
5528 here). The same bytes will be seen again in a
5529 later read(2), without the CRs. */
5531 if (errno
== EAGAIN
)
5534 ioctl (p
->outfd
, TIOCFLUSH
, &flags
);
5536 #endif /* BROKEN_PTY_READ_AFTER_EAGAIN */
5538 /* Put what we should have written in wait_queue. */
5539 write_queue_push (p
, cur_object
, cur_buf
, cur_len
, 1);
5540 wait_reading_process_output (0, 20 * 1000 * 1000,
5541 0, 0, Qnil
, NULL
, 0);
5542 /* Reread queue, to see what is left. */
5545 else if (errno
== EPIPE
)
5547 p
->raw_status_new
= 0;
5548 pset_status (p
, list2 (Qexit
, make_number (256)));
5549 p
->tick
= ++process_tick
;
5550 deactivate_process (proc
);
5551 error ("process %s no longer connected to pipe; closed it",
5555 /* This is a real error. */
5556 report_file_error ("writing to process", Fcons (proc
, Qnil
));
5562 while (!NILP (p
->write_queue
));
5565 DEFUN ("process-send-region", Fprocess_send_region
, Sprocess_send_region
,
5567 doc
: /* Send current contents of region as input to PROCESS.
5568 PROCESS may be a process, a buffer, the name of a process or buffer, or
5569 nil, indicating the current buffer's process.
5570 Called from program, takes three arguments, PROCESS, START and END.
5571 If the region is more than 500 characters long,
5572 it is sent in several bunches. This may happen even for shorter regions.
5573 Output from processes can arrive in between bunches. */)
5574 (Lisp_Object process
, Lisp_Object start
, Lisp_Object end
)
5577 ptrdiff_t start1
, end1
;
5579 proc
= get_process (process
);
5580 validate_region (&start
, &end
);
5582 if (XINT (start
) < GPT
&& XINT (end
) > GPT
)
5583 move_gap (XINT (start
));
5585 start1
= CHAR_TO_BYTE (XINT (start
));
5586 end1
= CHAR_TO_BYTE (XINT (end
));
5587 send_process (proc
, (char *) BYTE_POS_ADDR (start1
), end1
- start1
,
5588 Fcurrent_buffer ());
5593 DEFUN ("process-send-string", Fprocess_send_string
, Sprocess_send_string
,
5595 doc
: /* Send PROCESS the contents of STRING as input.
5596 PROCESS may be a process, a buffer, the name of a process or buffer, or
5597 nil, indicating the current buffer's process.
5598 If STRING is more than 500 characters long,
5599 it is sent in several bunches. This may happen even for shorter strings.
5600 Output from processes can arrive in between bunches. */)
5601 (Lisp_Object process
, Lisp_Object string
)
5604 CHECK_STRING (string
);
5605 proc
= get_process (process
);
5606 send_process (proc
, SSDATA (string
),
5607 SBYTES (string
), string
);
5611 /* Return the foreground process group for the tty/pty that
5612 the process P uses. */
5614 emacs_get_tty_pgrp (struct Lisp_Process
*p
)
5619 if (ioctl (p
->infd
, TIOCGPGRP
, &gid
) == -1 && ! NILP (p
->tty_name
))
5622 /* Some OS:es (Solaris 8/9) does not allow TIOCGPGRP from the
5623 master side. Try the slave side. */
5624 fd
= emacs_open (SSDATA (p
->tty_name
), O_RDONLY
, 0);
5628 ioctl (fd
, TIOCGPGRP
, &gid
);
5632 #endif /* defined (TIOCGPGRP ) */
5637 DEFUN ("process-running-child-p", Fprocess_running_child_p
,
5638 Sprocess_running_child_p
, 0, 1, 0,
5639 doc
: /* Return t if PROCESS has given the terminal to a child.
5640 If the operating system does not make it possible to find out,
5641 return t unconditionally. */)
5642 (Lisp_Object process
)
5644 /* Initialize in case ioctl doesn't exist or gives an error,
5645 in a way that will cause returning t. */
5648 struct Lisp_Process
*p
;
5650 proc
= get_process (process
);
5651 p
= XPROCESS (proc
);
5653 if (!EQ (p
->type
, Qreal
))
5654 error ("Process %s is not a subprocess",
5657 error ("Process %s is not active",
5660 gid
= emacs_get_tty_pgrp (p
);
5667 /* send a signal number SIGNO to PROCESS.
5668 If CURRENT_GROUP is t, that means send to the process group
5669 that currently owns the terminal being used to communicate with PROCESS.
5670 This is used for various commands in shell mode.
5671 If CURRENT_GROUP is lambda, that means send to the process group
5672 that currently owns the terminal, but only if it is NOT the shell itself.
5674 If NOMSG is zero, insert signal-announcements into process's buffers
5677 If we can, we try to signal PROCESS by sending control characters
5678 down the pty. This allows us to signal inferiors who have changed
5679 their uid, for which killpg would return an EPERM error. */
5682 process_send_signal (Lisp_Object process
, int signo
, Lisp_Object current_group
,
5686 register struct Lisp_Process
*p
;
5690 proc
= get_process (process
);
5691 p
= XPROCESS (proc
);
5693 if (!EQ (p
->type
, Qreal
))
5694 error ("Process %s is not a subprocess",
5697 error ("Process %s is not active",
5701 current_group
= Qnil
;
5703 /* If we are using pgrps, get a pgrp number and make it negative. */
5704 if (NILP (current_group
))
5705 /* Send the signal to the shell's process group. */
5709 #ifdef SIGNALS_VIA_CHARACTERS
5710 /* If possible, send signals to the entire pgrp
5711 by sending an input character to it. */
5714 cc_t
*sig_char
= NULL
;
5716 tcgetattr (p
->infd
, &t
);
5721 sig_char
= &t
.c_cc
[VINTR
];
5725 sig_char
= &t
.c_cc
[VQUIT
];
5729 #if defined (VSWTCH) && !defined (PREFER_VSUSP)
5730 sig_char
= &t
.c_cc
[VSWTCH
];
5732 sig_char
= &t
.c_cc
[VSUSP
];
5737 if (sig_char
&& *sig_char
!= CDISABLE
)
5739 send_process (proc
, (char *) sig_char
, 1, Qnil
);
5742 /* If we can't send the signal with a character,
5743 fall through and send it another way. */
5745 /* The code above may fall through if it can't
5746 handle the signal. */
5747 #endif /* defined (SIGNALS_VIA_CHARACTERS) */
5750 /* Get the current pgrp using the tty itself, if we have that.
5751 Otherwise, use the pty to get the pgrp.
5752 On pfa systems, saka@pfu.fujitsu.co.JP writes:
5753 "TIOCGPGRP symbol defined in sys/ioctl.h at E50.
5754 But, TIOCGPGRP does not work on E50 ;-P works fine on E60"
5755 His patch indicates that if TIOCGPGRP returns an error, then
5756 we should just assume that p->pid is also the process group id. */
5758 gid
= emacs_get_tty_pgrp (p
);
5761 /* If we can't get the information, assume
5762 the shell owns the tty. */
5765 /* It is not clear whether anything really can set GID to -1.
5766 Perhaps on some system one of those ioctls can or could do so.
5767 Or perhaps this is vestigial. */
5770 #else /* ! defined (TIOCGPGRP ) */
5771 /* Can't select pgrps on this system, so we know that
5772 the child itself heads the pgrp. */
5774 #endif /* ! defined (TIOCGPGRP ) */
5776 /* If current_group is lambda, and the shell owns the terminal,
5777 don't send any signal. */
5778 if (EQ (current_group
, Qlambda
) && gid
== p
->pid
)
5786 p
->raw_status_new
= 0;
5787 pset_status (p
, Qrun
);
5788 p
->tick
= ++process_tick
;
5791 status_notify (NULL
);
5792 redisplay_preserve_echo_area (13);
5795 #endif /* ! defined (SIGCONT) */
5799 flush_pending_output (p
->infd
);
5803 /* If we don't have process groups, send the signal to the immediate
5804 subprocess. That isn't really right, but it's better than any
5805 obvious alternative. */
5808 kill (p
->pid
, signo
);
5812 /* gid may be a pid, or minus a pgrp's number */
5814 if (!NILP (current_group
))
5816 if (ioctl (p
->infd
, TIOCSIGSEND
, signo
) == -1)
5817 EMACS_KILLPG (gid
, signo
);
5824 #else /* ! defined (TIOCSIGSEND) */
5825 EMACS_KILLPG (gid
, signo
);
5826 #endif /* ! defined (TIOCSIGSEND) */
5829 DEFUN ("interrupt-process", Finterrupt_process
, Sinterrupt_process
, 0, 2, 0,
5830 doc
: /* Interrupt process PROCESS.
5831 PROCESS may be a process, a buffer, or the name of a process or buffer.
5832 No arg or nil means current buffer's process.
5833 Second arg CURRENT-GROUP non-nil means send signal to
5834 the current process-group of the process's controlling terminal
5835 rather than to the process's own process group.
5836 If the process is a shell, this means interrupt current subjob
5837 rather than the shell.
5839 If CURRENT-GROUP is `lambda', and if the shell owns the terminal,
5840 don't send the signal. */)
5841 (Lisp_Object process
, Lisp_Object current_group
)
5843 process_send_signal (process
, SIGINT
, current_group
, 0);
5847 DEFUN ("kill-process", Fkill_process
, Skill_process
, 0, 2, 0,
5848 doc
: /* Kill process PROCESS. May be process or name of one.
5849 See function `interrupt-process' for more details on usage. */)
5850 (Lisp_Object process
, Lisp_Object current_group
)
5852 process_send_signal (process
, SIGKILL
, current_group
, 0);
5856 DEFUN ("quit-process", Fquit_process
, Squit_process
, 0, 2, 0,
5857 doc
: /* Send QUIT signal to process PROCESS. May be process or name of one.
5858 See function `interrupt-process' for more details on usage. */)
5859 (Lisp_Object process
, Lisp_Object current_group
)
5861 process_send_signal (process
, SIGQUIT
, current_group
, 0);
5865 DEFUN ("stop-process", Fstop_process
, Sstop_process
, 0, 2, 0,
5866 doc
: /* Stop process PROCESS. May be process or name of one.
5867 See function `interrupt-process' for more details on usage.
5868 If PROCESS is a network or serial process, inhibit handling of incoming
5870 (Lisp_Object process
, Lisp_Object current_group
)
5872 if (PROCESSP (process
) && (NETCONN_P (process
) || SERIALCONN_P (process
)))
5874 struct Lisp_Process
*p
;
5876 p
= XPROCESS (process
);
5877 if (NILP (p
->command
)
5880 FD_CLR (p
->infd
, &input_wait_mask
);
5881 FD_CLR (p
->infd
, &non_keyboard_wait_mask
);
5883 pset_command (p
, Qt
);
5887 error ("No SIGTSTP support");
5889 process_send_signal (process
, SIGTSTP
, current_group
, 0);
5894 DEFUN ("continue-process", Fcontinue_process
, Scontinue_process
, 0, 2, 0,
5895 doc
: /* Continue process PROCESS. May be process or name of one.
5896 See function `interrupt-process' for more details on usage.
5897 If PROCESS is a network or serial process, resume handling of incoming
5899 (Lisp_Object process
, Lisp_Object current_group
)
5901 if (PROCESSP (process
) && (NETCONN_P (process
) || SERIALCONN_P (process
)))
5903 struct Lisp_Process
*p
;
5905 p
= XPROCESS (process
);
5906 if (EQ (p
->command
, Qt
)
5908 && (!EQ (p
->filter
, Qt
) || EQ (p
->status
, Qlisten
)))
5910 FD_SET (p
->infd
, &input_wait_mask
);
5911 FD_SET (p
->infd
, &non_keyboard_wait_mask
);
5913 if (fd_info
[ p
->infd
].flags
& FILE_SERIAL
)
5914 PurgeComm (fd_info
[ p
->infd
].hnd
, PURGE_RXABORT
| PURGE_RXCLEAR
);
5915 #else /* not WINDOWSNT */
5916 tcflush (p
->infd
, TCIFLUSH
);
5917 #endif /* not WINDOWSNT */
5919 pset_command (p
, Qnil
);
5923 process_send_signal (process
, SIGCONT
, current_group
, 0);
5925 error ("No SIGCONT support");
5930 DEFUN ("signal-process", Fsignal_process
, Ssignal_process
,
5931 2, 2, "sProcess (name or number): \nnSignal code: ",
5932 doc
: /* Send PROCESS the signal with code SIGCODE.
5933 PROCESS may also be a number specifying the process id of the
5934 process to signal; in this case, the process need not be a child of
5936 SIGCODE may be an integer, or a symbol whose name is a signal name. */)
5937 (Lisp_Object process
, Lisp_Object sigcode
)
5941 if (STRINGP (process
))
5943 Lisp_Object tem
= Fget_process (process
);
5946 Lisp_Object process_number
=
5947 string_to_number (SSDATA (process
), 10, 1);
5948 if (INTEGERP (process_number
) || FLOATP (process_number
))
5949 tem
= process_number
;
5953 else if (!NUMBERP (process
))
5954 process
= get_process (process
);
5959 if (NUMBERP (process
))
5960 CONS_TO_INTEGER (process
, pid_t
, pid
);
5963 CHECK_PROCESS (process
);
5964 pid
= XPROCESS (process
)->pid
;
5966 error ("Cannot signal process %s", SDATA (XPROCESS (process
)->name
));
5969 #define parse_signal(NAME, VALUE) \
5970 else if (!xstrcasecmp (name, NAME)) \
5971 XSETINT (sigcode, VALUE)
5973 if (INTEGERP (sigcode
))
5974 CHECK_TYPE_RANGED_INTEGER (int, sigcode
);
5979 CHECK_SYMBOL (sigcode
);
5980 name
= SSDATA (SYMBOL_NAME (sigcode
));
5982 if (!strncmp (name
, "SIG", 3) || !strncmp (name
, "sig", 3))
5988 parse_signal ("usr1", SIGUSR1
);
5991 parse_signal ("usr2", SIGUSR2
);
5993 parse_signal ("term", SIGTERM
);
5995 parse_signal ("hup", SIGHUP
);
5997 parse_signal ("int", SIGINT
);
5999 parse_signal ("quit", SIGQUIT
);
6001 parse_signal ("ill", SIGILL
);
6002 parse_signal ("abrt", SIGABRT
);
6004 parse_signal ("emt", SIGEMT
);
6007 parse_signal ("kill", SIGKILL
);
6009 parse_signal ("fpe", SIGFPE
);
6011 parse_signal ("bus", SIGBUS
);
6013 parse_signal ("segv", SIGSEGV
);
6015 parse_signal ("sys", SIGSYS
);
6018 parse_signal ("pipe", SIGPIPE
);
6021 parse_signal ("alrm", SIGALRM
);
6024 parse_signal ("urg", SIGURG
);
6027 parse_signal ("stop", SIGSTOP
);
6030 parse_signal ("tstp", SIGTSTP
);
6033 parse_signal ("cont", SIGCONT
);
6036 parse_signal ("chld", SIGCHLD
);
6039 parse_signal ("ttin", SIGTTIN
);
6042 parse_signal ("ttou", SIGTTOU
);
6045 parse_signal ("io", SIGIO
);
6048 parse_signal ("xcpu", SIGXCPU
);
6051 parse_signal ("xfsz", SIGXFSZ
);
6054 parse_signal ("vtalrm", SIGVTALRM
);
6057 parse_signal ("prof", SIGPROF
);
6060 parse_signal ("winch", SIGWINCH
);
6063 parse_signal ("info", SIGINFO
);
6066 error ("Undefined signal name %s", name
);
6071 return make_number (kill (pid
, XINT (sigcode
)));
6074 DEFUN ("process-send-eof", Fprocess_send_eof
, Sprocess_send_eof
, 0, 1, 0,
6075 doc
: /* Make PROCESS see end-of-file in its input.
6076 EOF comes after any text already sent to it.
6077 PROCESS may be a process, a buffer, the name of a process or buffer, or
6078 nil, indicating the current buffer's process.
6079 If PROCESS is a network connection, or is a process communicating
6080 through a pipe (as opposed to a pty), then you cannot send any more
6081 text to PROCESS after you call this function.
6082 If PROCESS is a serial process, wait until all output written to the
6083 process has been transmitted to the serial port. */)
6084 (Lisp_Object process
)
6087 struct coding_system
*coding
;
6089 if (DATAGRAM_CONN_P (process
))
6092 proc
= get_process (process
);
6093 coding
= proc_encode_coding_system
[XPROCESS (proc
)->outfd
];
6095 /* Make sure the process is really alive. */
6096 if (XPROCESS (proc
)->raw_status_new
)
6097 update_status (XPROCESS (proc
));
6098 if (! EQ (XPROCESS (proc
)->status
, Qrun
))
6099 error ("Process %s not running", SDATA (XPROCESS (proc
)->name
));
6101 if (CODING_REQUIRE_FLUSHING (coding
))
6103 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
6104 send_process (proc
, "", 0, Qnil
);
6107 if (XPROCESS (proc
)->pty_flag
)
6108 send_process (proc
, "\004", 1, Qnil
);
6109 else if (EQ (XPROCESS (proc
)->type
, Qserial
))
6112 if (tcdrain (XPROCESS (proc
)->outfd
) != 0)
6113 error ("tcdrain() failed: %s", emacs_strerror (errno
));
6114 #endif /* not WINDOWSNT */
6115 /* Do nothing on Windows because writes are blocking. */
6119 int old_outfd
, new_outfd
;
6121 #ifdef HAVE_SHUTDOWN
6122 /* If this is a network connection, or socketpair is used
6123 for communication with the subprocess, call shutdown to cause EOF.
6124 (In some old system, shutdown to socketpair doesn't work.
6125 Then we just can't win.) */
6126 if (EQ (XPROCESS (proc
)->type
, Qnetwork
)
6127 || XPROCESS (proc
)->outfd
== XPROCESS (proc
)->infd
)
6128 shutdown (XPROCESS (proc
)->outfd
, 1);
6129 /* In case of socketpair, outfd == infd, so don't close it. */
6130 if (XPROCESS (proc
)->outfd
!= XPROCESS (proc
)->infd
)
6131 emacs_close (XPROCESS (proc
)->outfd
);
6132 #else /* not HAVE_SHUTDOWN */
6133 emacs_close (XPROCESS (proc
)->outfd
);
6134 #endif /* not HAVE_SHUTDOWN */
6135 new_outfd
= emacs_open (NULL_DEVICE
, O_WRONLY
, 0);
6138 old_outfd
= XPROCESS (proc
)->outfd
;
6140 if (!proc_encode_coding_system
[new_outfd
])
6141 proc_encode_coding_system
[new_outfd
]
6142 = xmalloc (sizeof (struct coding_system
));
6143 *proc_encode_coding_system
[new_outfd
]
6144 = *proc_encode_coding_system
[old_outfd
];
6145 memset (proc_encode_coding_system
[old_outfd
], 0,
6146 sizeof (struct coding_system
));
6148 XPROCESS (proc
)->outfd
= new_outfd
;
6155 /* The main Emacs thread records child processes in three places:
6157 - Vprocess_alist, for asynchronous subprocesses, which are child
6158 processes visible to Lisp.
6160 - deleted_pid_list, for child processes invisible to Lisp,
6161 typically because of delete-process. These are recorded so that
6162 the processes can be reaped when they exit, so that the operating
6163 system's process table is not cluttered by zombies.
6165 - the local variable PID in Fcall_process, call_process_cleanup and
6166 call_process_kill, for synchronous subprocesses.
6167 record_unwind_protect is used to make sure this process is not
6168 forgotten: if the user interrupts call-process and the child
6169 process refuses to exit immediately even with two C-g's,
6170 call_process_kill adds PID's contents to deleted_pid_list before
6173 The main Emacs thread invokes waitpid only on child processes that
6174 it creates and that have not been reaped. This avoid races on
6175 platforms such as GTK, where other threads create their own
6176 subprocesses which the main thread should not reap. For example,
6177 if the main thread attempted to reap an already-reaped child, it
6178 might inadvertently reap a GTK-created process that happened to
6179 have the same process ID. */
6181 /* Handle a SIGCHLD signal by looking for known child processes of
6182 Emacs whose status have changed. For each one found, record its
6185 All we do is change the status; we do not run sentinels or print
6186 notifications. That is saved for the next time keyboard input is
6187 done, in order to avoid timing errors.
6189 ** WARNING: this can be called during garbage collection.
6190 Therefore, it must not be fooled by the presence of mark bits in
6193 ** USG WARNING: Although it is not obvious from the documentation
6194 in signal(2), on a USG system the SIGCLD handler MUST NOT call
6195 signal() before executing at least one wait(), otherwise the
6196 handler will be called again, resulting in an infinite loop. The
6197 relevant portion of the documentation reads "SIGCLD signals will be
6198 queued and the signal-catching function will be continually
6199 reentered until the queue is empty". Invoking signal() causes the
6200 kernel to reexamine the SIGCLD queue. Fred Fish, UniSoft Systems
6203 ** Malloc WARNING: This should never call malloc either directly or
6204 indirectly; if it does, that is a bug */
6207 handle_child_signal (int sig
)
6211 /* Find the process that signaled us, and record its status. */
6213 /* The process can have been deleted by Fdelete_process, or have
6214 been started asynchronously by Fcall_process. */
6215 for (tail
= deleted_pid_list
; CONSP (tail
); tail
= XCDR (tail
))
6217 bool all_pids_are_fixnums
6218 = (MOST_NEGATIVE_FIXNUM
<= TYPE_MINIMUM (pid_t
)
6219 && TYPE_MAXIMUM (pid_t
) <= MOST_POSITIVE_FIXNUM
);
6220 Lisp_Object xpid
= XCAR (tail
);
6221 if (all_pids_are_fixnums
? INTEGERP (xpid
) : NUMBERP (xpid
))
6224 if (INTEGERP (xpid
))
6225 deleted_pid
= XINT (xpid
);
6227 deleted_pid
= XFLOAT_DATA (xpid
);
6228 if (child_status_changed (deleted_pid
, 0, 0))
6229 XSETCAR (tail
, Qnil
);
6233 /* Otherwise, if it is asynchronous, it is in Vprocess_alist. */
6234 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
6236 Lisp_Object proc
= XCDR (XCAR (tail
));
6237 struct Lisp_Process
*p
= XPROCESS (proc
);
6240 if (p
->alive
&& child_status_changed (p
->pid
, &status
, WUNTRACED
))
6242 /* Change the status of the process that was found. */
6243 p
->tick
= ++process_tick
;
6244 p
->raw_status
= status
;
6245 p
->raw_status_new
= 1;
6247 /* If process has terminated, stop waiting for its output. */
6248 if (WIFSIGNALED (status
) || WIFEXITED (status
))
6250 int clear_desc_flag
= 0;
6253 clear_desc_flag
= 1;
6255 /* clear_desc_flag avoids a compiler bug in Microsoft C. */
6256 if (clear_desc_flag
)
6258 FD_CLR (p
->infd
, &input_wait_mask
);
6259 FD_CLR (p
->infd
, &non_keyboard_wait_mask
);
6267 deliver_child_signal (int sig
)
6269 deliver_process_signal (sig
, handle_child_signal
);
6272 #endif /* SIGCHLD */
6276 exec_sentinel_unwind (Lisp_Object data
)
6278 pset_sentinel (XPROCESS (XCAR (data
)), XCDR (data
));
6283 exec_sentinel_error_handler (Lisp_Object error_val
)
6285 cmd_error_internal (error_val
, "error in process sentinel: ");
6287 update_echo_area ();
6288 Fsleep_for (make_number (2), Qnil
);
6293 exec_sentinel (Lisp_Object proc
, Lisp_Object reason
)
6295 Lisp_Object sentinel
, odeactivate
;
6296 struct Lisp_Process
*p
= XPROCESS (proc
);
6297 ptrdiff_t count
= SPECPDL_INDEX ();
6298 bool outer_running_asynch_code
= running_asynch_code
;
6299 int waiting
= waiting_for_user_input_p
;
6301 if (inhibit_sentinels
)
6304 /* No need to gcpro these, because all we do with them later
6305 is test them for EQness, and none of them should be a string. */
6306 odeactivate
= Vdeactivate_mark
;
6308 Lisp_Object obuffer
, okeymap
;
6309 XSETBUFFER (obuffer
, current_buffer
);
6310 okeymap
= BVAR (current_buffer
, keymap
);
6313 /* There's no good reason to let sentinels change the current
6314 buffer, and many callers of accept-process-output, sit-for, and
6315 friends don't expect current-buffer to be changed from under them. */
6316 record_unwind_current_buffer ();
6318 sentinel
= p
->sentinel
;
6319 if (NILP (sentinel
))
6322 /* Zilch the sentinel while it's running, to avoid recursive invocations;
6323 assure that it gets restored no matter how the sentinel exits. */
6324 pset_sentinel (p
, Qnil
);
6325 record_unwind_protect (exec_sentinel_unwind
, Fcons (proc
, sentinel
));
6326 /* Inhibit quit so that random quits don't screw up a running filter. */
6327 specbind (Qinhibit_quit
, Qt
);
6328 specbind (Qlast_nonmenu_event
, Qt
); /* Why? --Stef */
6330 /* In case we get recursively called,
6331 and we already saved the match data nonrecursively,
6332 save the same match data in safely recursive fashion. */
6333 if (outer_running_asynch_code
)
6336 tem
= Fmatch_data (Qnil
, Qnil
, Qnil
);
6337 restore_search_regs ();
6338 record_unwind_save_match_data ();
6339 Fset_match_data (tem
, Qt
);
6342 /* For speed, if a search happens within this code,
6343 save the match data in a special nonrecursive fashion. */
6344 running_asynch_code
= 1;
6346 internal_condition_case_1 (read_process_output_call
,
6348 Fcons (proc
, Fcons (reason
, Qnil
))),
6349 !NILP (Vdebug_on_error
) ? Qnil
: Qerror
,
6350 exec_sentinel_error_handler
);
6352 /* If we saved the match data nonrecursively, restore it now. */
6353 restore_search_regs ();
6354 running_asynch_code
= outer_running_asynch_code
;
6356 Vdeactivate_mark
= odeactivate
;
6358 /* Restore waiting_for_user_input_p as it was
6359 when we were called, in case the filter clobbered it. */
6360 waiting_for_user_input_p
= waiting
;
6363 if (! EQ (Fcurrent_buffer (), obuffer
)
6364 || ! EQ (current_buffer
->keymap
, okeymap
))
6366 /* But do it only if the caller is actually going to read events.
6367 Otherwise there's no need to make him wake up, and it could
6368 cause trouble (for example it would make sit_for return). */
6369 if (waiting_for_user_input_p
== -1)
6370 record_asynch_buffer_change ();
6372 unbind_to (count
, Qnil
);
6375 /* Report all recent events of a change in process status
6376 (either run the sentinel or output a message).
6377 This is usually done while Emacs is waiting for keyboard input
6378 but can be done at other times. */
6381 status_notify (struct Lisp_Process
*deleting_process
)
6383 register Lisp_Object proc
, buffer
;
6384 Lisp_Object tail
, msg
;
6385 struct gcpro gcpro1
, gcpro2
;
6389 /* We need to gcpro tail; if read_process_output calls a filter
6390 which deletes a process and removes the cons to which tail points
6391 from Vprocess_alist, and then causes a GC, tail is an unprotected
6395 /* Set this now, so that if new processes are created by sentinels
6396 that we run, we get called again to handle their status changes. */
6397 update_tick
= process_tick
;
6399 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
6402 register struct Lisp_Process
*p
;
6404 proc
= Fcdr (XCAR (tail
));
6405 p
= XPROCESS (proc
);
6407 if (p
->tick
!= p
->update_tick
)
6409 p
->update_tick
= p
->tick
;
6411 /* If process is still active, read any output that remains. */
6412 while (! EQ (p
->filter
, Qt
)
6413 && ! EQ (p
->status
, Qconnect
)
6414 && ! EQ (p
->status
, Qlisten
)
6415 /* Network or serial process not stopped: */
6416 && ! EQ (p
->command
, Qt
)
6418 && p
!= deleting_process
6419 && read_process_output (proc
, p
->infd
) > 0);
6423 /* Get the text to use for the message. */
6424 if (p
->raw_status_new
)
6426 msg
= status_message (p
);
6428 /* If process is terminated, deactivate it or delete it. */
6430 if (CONSP (p
->status
))
6431 symbol
= XCAR (p
->status
);
6433 if (EQ (symbol
, Qsignal
) || EQ (symbol
, Qexit
)
6434 || EQ (symbol
, Qclosed
))
6436 if (delete_exited_processes
)
6437 remove_process (proc
);
6439 deactivate_process (proc
);
6442 /* The actions above may have further incremented p->tick.
6443 So set p->update_tick again
6444 so that an error in the sentinel will not cause
6445 this code to be run again. */
6446 p
->update_tick
= p
->tick
;
6447 /* Now output the message suitably. */
6448 if (!NILP (p
->sentinel
))
6449 exec_sentinel (proc
, msg
);
6450 /* Don't bother with a message in the buffer
6451 when a process becomes runnable. */
6452 else if (!EQ (symbol
, Qrun
) && !NILP (buffer
))
6455 struct buffer
*old
= current_buffer
;
6456 ptrdiff_t opoint
, opoint_byte
;
6457 ptrdiff_t before
, before_byte
;
6459 /* Avoid error if buffer is deleted
6460 (probably that's why the process is dead, too) */
6461 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
6463 Fset_buffer (buffer
);
6466 opoint_byte
= PT_BYTE
;
6467 /* Insert new output into buffer
6468 at the current end-of-output marker,
6469 thus preserving logical ordering of input and output. */
6470 if (XMARKER (p
->mark
)->buffer
)
6471 Fgoto_char (p
->mark
);
6473 SET_PT_BOTH (ZV
, ZV_BYTE
);
6476 before_byte
= PT_BYTE
;
6478 tem
= BVAR (current_buffer
, read_only
);
6479 bset_read_only (current_buffer
, Qnil
);
6480 insert_string ("\nProcess ");
6481 { /* FIXME: temporary kludge */
6482 Lisp_Object tem2
= p
->name
; Finsert (1, &tem2
); }
6483 insert_string (" ");
6485 bset_read_only (current_buffer
, tem
);
6486 set_marker_both (p
->mark
, p
->buffer
, PT
, PT_BYTE
);
6488 if (opoint
>= before
)
6489 SET_PT_BOTH (opoint
+ (PT
- before
),
6490 opoint_byte
+ (PT_BYTE
- before_byte
));
6492 SET_PT_BOTH (opoint
, opoint_byte
);
6494 set_buffer_internal (old
);
6499 update_mode_lines
++; /* in case buffers use %s in mode-line-format */
6504 DEFUN ("set-process-coding-system", Fset_process_coding_system
,
6505 Sset_process_coding_system
, 1, 3, 0,
6506 doc
: /* Set coding systems of PROCESS to DECODING and ENCODING.
6507 DECODING will be used to decode subprocess output and ENCODING to
6508 encode subprocess input. */)
6509 (register Lisp_Object process
, Lisp_Object decoding
, Lisp_Object encoding
)
6511 register struct Lisp_Process
*p
;
6513 CHECK_PROCESS (process
);
6514 p
= XPROCESS (process
);
6516 error ("Input file descriptor of %s closed", SDATA (p
->name
));
6518 error ("Output file descriptor of %s closed", SDATA (p
->name
));
6519 Fcheck_coding_system (decoding
);
6520 Fcheck_coding_system (encoding
);
6521 encoding
= coding_inherit_eol_type (encoding
, Qnil
);
6522 pset_decode_coding_system (p
, decoding
);
6523 pset_encode_coding_system (p
, encoding
);
6524 setup_process_coding_systems (process
);
6529 DEFUN ("process-coding-system",
6530 Fprocess_coding_system
, Sprocess_coding_system
, 1, 1, 0,
6531 doc
: /* Return a cons of coding systems for decoding and encoding of PROCESS. */)
6532 (register Lisp_Object process
)
6534 CHECK_PROCESS (process
);
6535 return Fcons (XPROCESS (process
)->decode_coding_system
,
6536 XPROCESS (process
)->encode_coding_system
);
6539 DEFUN ("set-process-filter-multibyte", Fset_process_filter_multibyte
,
6540 Sset_process_filter_multibyte
, 2, 2, 0,
6541 doc
: /* Set multibyteness of the strings given to PROCESS's filter.
6542 If FLAG is non-nil, the filter is given multibyte strings.
6543 If FLAG is nil, the filter is given unibyte strings. In this case,
6544 all character code conversion except for end-of-line conversion is
6546 (Lisp_Object process
, Lisp_Object flag
)
6548 register struct Lisp_Process
*p
;
6550 CHECK_PROCESS (process
);
6551 p
= XPROCESS (process
);
6553 pset_decode_coding_system
6554 (p
, raw_text_coding_system (p
->decode_coding_system
));
6555 setup_process_coding_systems (process
);
6560 DEFUN ("process-filter-multibyte-p", Fprocess_filter_multibyte_p
,
6561 Sprocess_filter_multibyte_p
, 1, 1, 0,
6562 doc
: /* Return t if a multibyte string is given to PROCESS's filter.*/)
6563 (Lisp_Object process
)
6565 register struct Lisp_Process
*p
;
6566 struct coding_system
*coding
;
6568 CHECK_PROCESS (process
);
6569 p
= XPROCESS (process
);
6570 coding
= proc_decode_coding_system
[p
->infd
];
6571 return (CODING_FOR_UNIBYTE (coding
) ? Qnil
: Qt
);
6580 add_gpm_wait_descriptor (int desc
)
6582 add_keyboard_wait_descriptor (desc
);
6586 delete_gpm_wait_descriptor (int desc
)
6588 delete_keyboard_wait_descriptor (desc
);
6593 # ifdef USABLE_SIGIO
6595 /* Return nonzero if *MASK has a bit set
6596 that corresponds to one of the keyboard input descriptors. */
6599 keyboard_bit_set (fd_set
*mask
)
6603 for (fd
= 0; fd
<= max_input_desc
; fd
++)
6604 if (FD_ISSET (fd
, mask
) && FD_ISSET (fd
, &input_wait_mask
)
6605 && !FD_ISSET (fd
, &non_keyboard_wait_mask
))
6612 #else /* not subprocesses */
6614 /* Defined on msdos.c. */
6615 extern int sys_select (int, SELECT_TYPE
*, SELECT_TYPE
*, SELECT_TYPE
*,
6616 EMACS_TIME
*, void *);
6618 /* Implementation of wait_reading_process_output, assuming that there
6619 are no subprocesses. Used only by the MS-DOS build.
6621 Wait for timeout to elapse and/or keyboard input to be available.
6625 If negative, gobble data immediately available but don't wait for any.
6628 an additional duration to wait, measured in nanoseconds
6629 If TIME_LIMIT is zero, then:
6630 If NSECS == 0, there is no limit.
6631 If NSECS > 0, the timeout consists of NSECS only.
6632 If NSECS < 0, gobble data immediately, as if TIME_LIMIT were negative.
6635 0 to ignore keyboard input, or
6636 1 to return when input is available, or
6637 -1 means caller will actually read the input, so don't throw to
6640 see full version for other parameters. We know that wait_proc will
6641 always be NULL, since `subprocesses' isn't defined.
6643 DO_DISPLAY means redisplay should be done to show subprocess
6644 output that arrives.
6646 Return true if we received input from any process. */
6649 wait_reading_process_output (intmax_t time_limit
, int nsecs
, int read_kbd
,
6651 Lisp_Object wait_for_cell
,
6652 struct Lisp_Process
*wait_proc
, int just_wait_proc
)
6655 EMACS_TIME end_time
, timeout
;
6662 else if (TYPE_MAXIMUM (time_t) < time_limit
)
6663 time_limit
= TYPE_MAXIMUM (time_t);
6665 /* What does time_limit really mean? */
6666 if (time_limit
|| 0 < nsecs
)
6668 timeout
= make_emacs_time (time_limit
, nsecs
);
6669 end_time
= add_emacs_time (current_emacs_time (), timeout
);
6672 /* Turn off periodic alarms (in case they are in use)
6673 and then turn off any other atimers,
6674 because the select emulator uses alarms. */
6676 turn_on_atimers (0);
6680 int timeout_reduced_for_timers
= 0;
6681 SELECT_TYPE waitchannels
;
6684 /* If calling from keyboard input, do not quit
6685 since we want to return C-g as an input character.
6686 Otherwise, do pending quit if requested. */
6690 /* Exit now if the cell we're waiting for became non-nil. */
6691 if (! NILP (wait_for_cell
) && ! NILP (XCAR (wait_for_cell
)))
6694 /* Compute time from now till when time limit is up */
6695 /* Exit if already run out */
6698 /* A negative timeout means
6699 gobble output available now
6700 but don't wait at all. */
6702 timeout
= make_emacs_time (0, 0);
6704 else if (time_limit
|| 0 < nsecs
)
6706 EMACS_TIME now
= current_emacs_time ();
6707 if (EMACS_TIME_LE (end_time
, now
))
6709 timeout
= sub_emacs_time (end_time
, now
);
6713 timeout
= make_emacs_time (100000, 0);
6716 /* If our caller will not immediately handle keyboard events,
6717 run timer events directly.
6718 (Callers that will immediately read keyboard events
6719 call timer_delay on their own.) */
6720 if (NILP (wait_for_cell
))
6722 EMACS_TIME timer_delay
;
6726 unsigned old_timers_run
= timers_run
;
6727 timer_delay
= timer_check ();
6728 if (timers_run
!= old_timers_run
&& do_display
)
6729 /* We must retry, since a timer may have requeued itself
6730 and that could alter the time delay. */
6731 redisplay_preserve_echo_area (14);
6735 while (!detect_input_pending ());
6737 /* If there is unread keyboard input, also return. */
6739 && requeued_events_pending_p ())
6742 if (EMACS_TIME_VALID_P (timer_delay
) && 0 <= nsecs
)
6744 if (EMACS_TIME_LT (timer_delay
, timeout
))
6746 timeout
= timer_delay
;
6747 timeout_reduced_for_timers
= 1;
6752 /* Cause C-g and alarm signals to take immediate action,
6753 and cause input available signals to zero out timeout. */
6755 set_waiting_for_input (&timeout
);
6757 /* If a frame has been newly mapped and needs updating,
6758 reprocess its display stuff. */
6759 if (frame_garbaged
&& do_display
)
6761 clear_waiting_for_input ();
6762 redisplay_preserve_echo_area (15);
6764 set_waiting_for_input (&timeout
);
6767 /* Wait till there is something to do. */
6768 FD_ZERO (&waitchannels
);
6769 if (read_kbd
&& detect_input_pending ())
6773 if (read_kbd
|| !NILP (wait_for_cell
))
6774 FD_SET (0, &waitchannels
);
6775 nfds
= pselect (1, &waitchannels
, NULL
, NULL
, &timeout
, NULL
);
6780 /* Make C-g and alarm signals set flags again */
6781 clear_waiting_for_input ();
6783 /* If we woke up due to SIGWINCH, actually change size now. */
6784 do_pending_window_change (0);
6786 if ((time_limit
|| nsecs
) && nfds
== 0 && ! timeout_reduced_for_timers
)
6787 /* We waited the full specified time, so return now. */
6792 /* If the system call was interrupted, then go around the
6794 if (xerrno
== EINTR
)
6795 FD_ZERO (&waitchannels
);
6797 error ("select error: %s", emacs_strerror (xerrno
));
6800 /* Check for keyboard input */
6803 && detect_input_pending_run_timers (do_display
))
6805 swallow_events (do_display
);
6806 if (detect_input_pending_run_timers (do_display
))
6810 /* If there is unread keyboard input, also return. */
6812 && requeued_events_pending_p ())
6815 /* If wait_for_cell. check for keyboard input
6816 but don't run any timers.
6817 ??? (It seems wrong to me to check for keyboard
6818 input at all when wait_for_cell, but the code
6819 has been this way since July 1994.
6820 Try changing this after version 19.31.) */
6821 if (! NILP (wait_for_cell
)
6822 && detect_input_pending ())
6824 swallow_events (do_display
);
6825 if (detect_input_pending ())
6829 /* Exit now if the cell we're waiting for became non-nil. */
6830 if (! NILP (wait_for_cell
) && ! NILP (XCAR (wait_for_cell
)))
6839 #endif /* not subprocesses */
6841 /* The following functions are needed even if async subprocesses are
6842 not supported. Some of them are no-op stubs in that case. */
6844 /* Add DESC to the set of keyboard input descriptors. */
6847 add_keyboard_wait_descriptor (int desc
)
6849 #ifdef subprocesses /* actually means "not MSDOS" */
6850 FD_SET (desc
, &input_wait_mask
);
6851 FD_SET (desc
, &non_process_wait_mask
);
6852 if (desc
> max_input_desc
)
6853 max_input_desc
= desc
;
6857 /* From now on, do not expect DESC to give keyboard input. */
6860 delete_keyboard_wait_descriptor (int desc
)
6864 int lim
= max_input_desc
;
6866 FD_CLR (desc
, &input_wait_mask
);
6867 FD_CLR (desc
, &non_process_wait_mask
);
6869 if (desc
== max_input_desc
)
6870 for (fd
= 0; fd
< lim
; fd
++)
6871 if (FD_ISSET (fd
, &input_wait_mask
) || FD_ISSET (fd
, &write_mask
))
6872 max_input_desc
= fd
;
6876 /* Setup coding systems of PROCESS. */
6879 setup_process_coding_systems (Lisp_Object process
)
6882 struct Lisp_Process
*p
= XPROCESS (process
);
6884 int outch
= p
->outfd
;
6885 Lisp_Object coding_system
;
6887 if (inch
< 0 || outch
< 0)
6890 if (!proc_decode_coding_system
[inch
])
6891 proc_decode_coding_system
[inch
] = xmalloc (sizeof (struct coding_system
));
6892 coding_system
= p
->decode_coding_system
;
6893 if (! NILP (p
->filter
))
6895 else if (BUFFERP (p
->buffer
))
6897 if (NILP (BVAR (XBUFFER (p
->buffer
), enable_multibyte_characters
)))
6898 coding_system
= raw_text_coding_system (coding_system
);
6900 setup_coding_system (coding_system
, proc_decode_coding_system
[inch
]);
6902 if (!proc_encode_coding_system
[outch
])
6903 proc_encode_coding_system
[outch
] = xmalloc (sizeof (struct coding_system
));
6904 setup_coding_system (p
->encode_coding_system
,
6905 proc_encode_coding_system
[outch
]);
6909 /* Close all descriptors currently in use for communication
6910 with subprocess. This is used in a newly-forked subprocess
6911 to get rid of irrelevant descriptors. */
6914 close_process_descs (void)
6918 for (i
= 0; i
< MAXDESC
; i
++)
6920 Lisp_Object process
;
6921 process
= chan_process
[i
];
6922 if (!NILP (process
))
6924 int in
= XPROCESS (process
)->infd
;
6925 int out
= XPROCESS (process
)->outfd
;
6928 if (out
>= 0 && in
!= out
)
6935 DEFUN ("get-buffer-process", Fget_buffer_process
, Sget_buffer_process
, 1, 1, 0,
6936 doc
: /* Return the (or a) process associated with BUFFER.
6937 BUFFER may be a buffer or the name of one. */)
6938 (register Lisp_Object buffer
)
6941 register Lisp_Object buf
, tail
, proc
;
6943 if (NILP (buffer
)) return Qnil
;
6944 buf
= Fget_buffer (buffer
);
6945 if (NILP (buf
)) return Qnil
;
6947 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
6949 proc
= Fcdr (XCAR (tail
));
6950 if (PROCESSP (proc
) && EQ (XPROCESS (proc
)->buffer
, buf
))
6953 #endif /* subprocesses */
6957 DEFUN ("process-inherit-coding-system-flag",
6958 Fprocess_inherit_coding_system_flag
, Sprocess_inherit_coding_system_flag
,
6960 doc
: /* Return the value of inherit-coding-system flag for PROCESS.
6961 If this flag is t, `buffer-file-coding-system' of the buffer
6962 associated with PROCESS will inherit the coding system used to decode
6963 the process output. */)
6964 (register Lisp_Object process
)
6967 CHECK_PROCESS (process
);
6968 return XPROCESS (process
)->inherit_coding_system_flag
? Qt
: Qnil
;
6970 /* Ignore the argument and return the value of
6971 inherit-process-coding-system. */
6972 return inherit_process_coding_system
? Qt
: Qnil
;
6976 /* Kill all processes associated with `buffer'.
6977 If `buffer' is nil, kill all processes */
6980 kill_buffer_processes (Lisp_Object buffer
)
6983 Lisp_Object tail
, proc
;
6985 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
6987 proc
= XCDR (XCAR (tail
));
6989 && (NILP (buffer
) || EQ (XPROCESS (proc
)->buffer
, buffer
)))
6991 if (NETCONN_P (proc
) || SERIALCONN_P (proc
))
6992 Fdelete_process (proc
);
6993 else if (XPROCESS (proc
)->infd
>= 0)
6994 process_send_signal (proc
, SIGHUP
, Qnil
, 1);
6997 #else /* subprocesses */
6998 /* Since we have no subprocesses, this does nothing. */
6999 #endif /* subprocesses */
7002 DEFUN ("waiting-for-user-input-p", Fwaiting_for_user_input_p
,
7003 Swaiting_for_user_input_p
, 0, 0, 0,
7004 doc
: /* Returns non-nil if Emacs is waiting for input from the user.
7005 This is intended for use by asynchronous process output filters and sentinels. */)
7009 return (waiting_for_user_input_p
? Qt
: Qnil
);
7015 /* Stop reading input from keyboard sources. */
7018 hold_keyboard_input (void)
7023 /* Resume reading input from keyboard sources. */
7026 unhold_keyboard_input (void)
7031 /* Return non-zero if keyboard input is on hold, zero otherwise. */
7034 kbd_on_hold_p (void)
7036 return kbd_is_on_hold
;
7040 /* Enumeration of and access to system processes a-la ps(1). */
7042 DEFUN ("list-system-processes", Flist_system_processes
, Slist_system_processes
,
7044 doc
: /* Return a list of numerical process IDs of all running processes.
7045 If this functionality is unsupported, return nil.
7047 See `process-attributes' for getting attributes of a process given its ID. */)
7050 return list_system_processes ();
7053 DEFUN ("process-attributes", Fprocess_attributes
,
7054 Sprocess_attributes
, 1, 1, 0,
7055 doc
: /* Return attributes of the process given by its PID, a number.
7057 Value is an alist where each element is a cons cell of the form
7061 If this functionality is unsupported, the value is nil.
7063 See `list-system-processes' for getting a list of all process IDs.
7065 The KEYs of the attributes that this function may return are listed
7066 below, together with the type of the associated VALUE (in parentheses).
7067 Not all platforms support all of these attributes; unsupported
7068 attributes will not appear in the returned alist.
7069 Unless explicitly indicated otherwise, numbers can have either
7070 integer or floating point values.
7072 euid -- Effective user User ID of the process (number)
7073 user -- User name corresponding to euid (string)
7074 egid -- Effective user Group ID of the process (number)
7075 group -- Group name corresponding to egid (string)
7076 comm -- Command name (executable name only) (string)
7077 state -- Process state code, such as "S", "R", or "T" (string)
7078 ppid -- Parent process ID (number)
7079 pgrp -- Process group ID (number)
7080 sess -- Session ID, i.e. process ID of session leader (number)
7081 ttname -- Controlling tty name (string)
7082 tpgid -- ID of foreground process group on the process's tty (number)
7083 minflt -- number of minor page faults (number)
7084 majflt -- number of major page faults (number)
7085 cminflt -- cumulative number of minor page faults (number)
7086 cmajflt -- cumulative number of major page faults (number)
7087 utime -- user time used by the process, in (current-time) format,
7088 which is a list of integers (HIGH LOW USEC PSEC)
7089 stime -- system time used by the process (current-time)
7090 time -- sum of utime and stime (current-time)
7091 cutime -- user time used by the process and its children (current-time)
7092 cstime -- system time used by the process and its children (current-time)
7093 ctime -- sum of cutime and cstime (current-time)
7094 pri -- priority of the process (number)
7095 nice -- nice value of the process (number)
7096 thcount -- process thread count (number)
7097 start -- time the process started (current-time)
7098 vsize -- virtual memory size of the process in KB's (number)
7099 rss -- resident set size of the process in KB's (number)
7100 etime -- elapsed time the process is running, in (HIGH LOW USEC PSEC) format
7101 pcpu -- percents of CPU time used by the process (floating-point number)
7102 pmem -- percents of total physical memory used by process's resident set
7103 (floating-point number)
7104 args -- command line which invoked the process (string). */)
7107 return system_process_attributes (pid
);
7111 /* This is not called "init_process" because that is the name of a
7112 Mach system call, so it would cause problems on Darwin systems. */
7114 init_process_emacs (void)
7119 inhibit_sentinels
= 0;
7123 if (! noninteractive
|| initialized
)
7126 struct sigaction action
;
7127 emacs_sigaction_init (&action
, deliver_child_signal
);
7128 sigaction (SIGCHLD
, &action
, 0);
7132 FD_ZERO (&input_wait_mask
);
7133 FD_ZERO (&non_keyboard_wait_mask
);
7134 FD_ZERO (&non_process_wait_mask
);
7135 FD_ZERO (&write_mask
);
7136 max_process_desc
= 0;
7137 memset (fd_callback_info
, 0, sizeof (fd_callback_info
));
7139 #ifdef NON_BLOCKING_CONNECT
7140 FD_ZERO (&connect_wait_mask
);
7141 num_pending_connects
= 0;
7144 #ifdef ADAPTIVE_READ_BUFFERING
7145 process_output_delay_count
= 0;
7146 process_output_skip
= 0;
7149 /* Don't do this, it caused infinite select loops. The display
7150 method should call add_keyboard_wait_descriptor on stdin if it
7153 FD_SET (0, &input_wait_mask
);
7156 Vprocess_alist
= Qnil
;
7158 deleted_pid_list
= Qnil
;
7160 for (i
= 0; i
< MAXDESC
; i
++)
7162 chan_process
[i
] = Qnil
;
7163 proc_buffered_char
[i
] = -1;
7165 memset (proc_decode_coding_system
, 0, sizeof proc_decode_coding_system
);
7166 memset (proc_encode_coding_system
, 0, sizeof proc_encode_coding_system
);
7167 #ifdef DATAGRAM_SOCKETS
7168 memset (datagram_address
, 0, sizeof datagram_address
);
7172 Lisp_Object subfeatures
= Qnil
;
7173 const struct socket_options
*sopt
;
7175 #define ADD_SUBFEATURE(key, val) \
7176 subfeatures = pure_cons (pure_cons (key, pure_cons (val, Qnil)), subfeatures)
7178 #ifdef NON_BLOCKING_CONNECT
7179 ADD_SUBFEATURE (QCnowait
, Qt
);
7181 #ifdef DATAGRAM_SOCKETS
7182 ADD_SUBFEATURE (QCtype
, Qdatagram
);
7184 #ifdef HAVE_SEQPACKET
7185 ADD_SUBFEATURE (QCtype
, Qseqpacket
);
7187 #ifdef HAVE_LOCAL_SOCKETS
7188 ADD_SUBFEATURE (QCfamily
, Qlocal
);
7190 ADD_SUBFEATURE (QCfamily
, Qipv4
);
7192 ADD_SUBFEATURE (QCfamily
, Qipv6
);
7194 #ifdef HAVE_GETSOCKNAME
7195 ADD_SUBFEATURE (QCservice
, Qt
);
7197 ADD_SUBFEATURE (QCserver
, Qt
);
7199 for (sopt
= socket_options
; sopt
->name
; sopt
++)
7200 subfeatures
= pure_cons (intern_c_string (sopt
->name
), subfeatures
);
7202 Fprovide (intern_c_string ("make-network-process"), subfeatures
);
7205 #if defined (DARWIN_OS)
7206 /* PTYs are broken on Darwin < 6, but are sometimes useful for interactive
7207 processes. As such, we only change the default value. */
7210 char const *release
= (STRINGP (Voperating_system_release
)
7211 ? SSDATA (Voperating_system_release
)
7213 if (!release
|| !release
[0] || (release
[0] < '7' && release
[1] == '.')) {
7214 Vprocess_connection_type
= Qnil
;
7218 #endif /* subprocesses */
7223 syms_of_process (void)
7227 DEFSYM (Qprocessp
, "processp");
7228 DEFSYM (Qrun
, "run");
7229 DEFSYM (Qstop
, "stop");
7230 DEFSYM (Qsignal
, "signal");
7232 /* Qexit is already staticpro'd by syms_of_eval; don't staticpro it
7235 Qexit = intern_c_string ("exit");
7236 staticpro (&Qexit); */
7238 DEFSYM (Qopen
, "open");
7239 DEFSYM (Qclosed
, "closed");
7240 DEFSYM (Qconnect
, "connect");
7241 DEFSYM (Qfailed
, "failed");
7242 DEFSYM (Qlisten
, "listen");
7243 DEFSYM (Qlocal
, "local");
7244 DEFSYM (Qipv4
, "ipv4");
7246 DEFSYM (Qipv6
, "ipv6");
7248 DEFSYM (Qdatagram
, "datagram");
7249 DEFSYM (Qseqpacket
, "seqpacket");
7251 DEFSYM (QCport
, ":port");
7252 DEFSYM (QCspeed
, ":speed");
7253 DEFSYM (QCprocess
, ":process");
7255 DEFSYM (QCbytesize
, ":bytesize");
7256 DEFSYM (QCstopbits
, ":stopbits");
7257 DEFSYM (QCparity
, ":parity");
7258 DEFSYM (Qodd
, "odd");
7259 DEFSYM (Qeven
, "even");
7260 DEFSYM (QCflowcontrol
, ":flowcontrol");
7263 DEFSYM (QCsummary
, ":summary");
7265 DEFSYM (Qreal
, "real");
7266 DEFSYM (Qnetwork
, "network");
7267 DEFSYM (Qserial
, "serial");
7268 DEFSYM (QCbuffer
, ":buffer");
7269 DEFSYM (QChost
, ":host");
7270 DEFSYM (QCservice
, ":service");
7271 DEFSYM (QClocal
, ":local");
7272 DEFSYM (QCremote
, ":remote");
7273 DEFSYM (QCcoding
, ":coding");
7274 DEFSYM (QCserver
, ":server");
7275 DEFSYM (QCnowait
, ":nowait");
7276 DEFSYM (QCsentinel
, ":sentinel");
7277 DEFSYM (QClog
, ":log");
7278 DEFSYM (QCnoquery
, ":noquery");
7279 DEFSYM (QCstop
, ":stop");
7280 DEFSYM (QCoptions
, ":options");
7281 DEFSYM (QCplist
, ":plist");
7283 DEFSYM (Qlast_nonmenu_event
, "last-nonmenu-event");
7285 staticpro (&Vprocess_alist
);
7287 staticpro (&deleted_pid_list
);
7290 #endif /* subprocesses */
7292 DEFSYM (QCname
, ":name");
7293 DEFSYM (QCtype
, ":type");
7295 DEFSYM (Qeuid
, "euid");
7296 DEFSYM (Qegid
, "egid");
7297 DEFSYM (Quser
, "user");
7298 DEFSYM (Qgroup
, "group");
7299 DEFSYM (Qcomm
, "comm");
7300 DEFSYM (Qstate
, "state");
7301 DEFSYM (Qppid
, "ppid");
7302 DEFSYM (Qpgrp
, "pgrp");
7303 DEFSYM (Qsess
, "sess");
7304 DEFSYM (Qttname
, "ttname");
7305 DEFSYM (Qtpgid
, "tpgid");
7306 DEFSYM (Qminflt
, "minflt");
7307 DEFSYM (Qmajflt
, "majflt");
7308 DEFSYM (Qcminflt
, "cminflt");
7309 DEFSYM (Qcmajflt
, "cmajflt");
7310 DEFSYM (Qutime
, "utime");
7311 DEFSYM (Qstime
, "stime");
7312 DEFSYM (Qtime
, "time");
7313 DEFSYM (Qcutime
, "cutime");
7314 DEFSYM (Qcstime
, "cstime");
7315 DEFSYM (Qctime
, "ctime");
7316 DEFSYM (Qpri
, "pri");
7317 DEFSYM (Qnice
, "nice");
7318 DEFSYM (Qthcount
, "thcount");
7319 DEFSYM (Qstart
, "start");
7320 DEFSYM (Qvsize
, "vsize");
7321 DEFSYM (Qrss
, "rss");
7322 DEFSYM (Qetime
, "etime");
7323 DEFSYM (Qpcpu
, "pcpu");
7324 DEFSYM (Qpmem
, "pmem");
7325 DEFSYM (Qargs
, "args");
7327 DEFVAR_BOOL ("delete-exited-processes", delete_exited_processes
,
7328 doc
: /* Non-nil means delete processes immediately when they exit.
7329 A value of nil means don't delete them until `list-processes' is run. */);
7331 delete_exited_processes
= 1;
7334 DEFVAR_LISP ("process-connection-type", Vprocess_connection_type
,
7335 doc
: /* Control type of device used to communicate with subprocesses.
7336 Values are nil to use a pipe, or t or `pty' to use a pty.
7337 The value has no effect if the system has no ptys or if all ptys are busy:
7338 then a pipe is used in any case.
7339 The value takes effect when `start-process' is called. */);
7340 Vprocess_connection_type
= Qt
;
7342 #ifdef ADAPTIVE_READ_BUFFERING
7343 DEFVAR_LISP ("process-adaptive-read-buffering", Vprocess_adaptive_read_buffering
,
7344 doc
: /* If non-nil, improve receive buffering by delaying after short reads.
7345 On some systems, when Emacs reads the output from a subprocess, the output data
7346 is read in very small blocks, potentially resulting in very poor performance.
7347 This behavior can be remedied to some extent by setting this variable to a
7348 non-nil value, as it will automatically delay reading from such processes, to
7349 allow them to produce more output before Emacs tries to read it.
7350 If the value is t, the delay is reset after each write to the process; any other
7351 non-nil value means that the delay is not reset on write.
7352 The variable takes effect when `start-process' is called. */);
7353 Vprocess_adaptive_read_buffering
= Qt
;
7356 defsubr (&Sprocessp
);
7357 defsubr (&Sget_process
);
7358 defsubr (&Sdelete_process
);
7359 defsubr (&Sprocess_status
);
7360 defsubr (&Sprocess_exit_status
);
7361 defsubr (&Sprocess_id
);
7362 defsubr (&Sprocess_name
);
7363 defsubr (&Sprocess_tty_name
);
7364 defsubr (&Sprocess_command
);
7365 defsubr (&Sset_process_buffer
);
7366 defsubr (&Sprocess_buffer
);
7367 defsubr (&Sprocess_mark
);
7368 defsubr (&Sset_process_filter
);
7369 defsubr (&Sprocess_filter
);
7370 defsubr (&Sset_process_sentinel
);
7371 defsubr (&Sprocess_sentinel
);
7372 defsubr (&Sset_process_window_size
);
7373 defsubr (&Sset_process_inherit_coding_system_flag
);
7374 defsubr (&Sset_process_query_on_exit_flag
);
7375 defsubr (&Sprocess_query_on_exit_flag
);
7376 defsubr (&Sprocess_contact
);
7377 defsubr (&Sprocess_plist
);
7378 defsubr (&Sset_process_plist
);
7379 defsubr (&Sprocess_list
);
7380 defsubr (&Sstart_process
);
7381 defsubr (&Sserial_process_configure
);
7382 defsubr (&Smake_serial_process
);
7383 defsubr (&Sset_network_process_option
);
7384 defsubr (&Smake_network_process
);
7385 defsubr (&Sformat_network_address
);
7386 #if defined (HAVE_NET_IF_H)
7388 defsubr (&Snetwork_interface_list
);
7390 #if defined (SIOCGIFADDR) || defined (SIOCGIFHWADDR) || defined (SIOCGIFFLAGS)
7391 defsubr (&Snetwork_interface_info
);
7393 #endif /* defined (HAVE_NET_IF_H) */
7394 #ifdef DATAGRAM_SOCKETS
7395 defsubr (&Sprocess_datagram_address
);
7396 defsubr (&Sset_process_datagram_address
);
7398 defsubr (&Saccept_process_output
);
7399 defsubr (&Sprocess_send_region
);
7400 defsubr (&Sprocess_send_string
);
7401 defsubr (&Sinterrupt_process
);
7402 defsubr (&Skill_process
);
7403 defsubr (&Squit_process
);
7404 defsubr (&Sstop_process
);
7405 defsubr (&Scontinue_process
);
7406 defsubr (&Sprocess_running_child_p
);
7407 defsubr (&Sprocess_send_eof
);
7408 defsubr (&Ssignal_process
);
7409 defsubr (&Swaiting_for_user_input_p
);
7410 defsubr (&Sprocess_type
);
7411 defsubr (&Sset_process_coding_system
);
7412 defsubr (&Sprocess_coding_system
);
7413 defsubr (&Sset_process_filter_multibyte
);
7414 defsubr (&Sprocess_filter_multibyte_p
);
7416 #endif /* subprocesses */
7418 defsubr (&Sget_buffer_process
);
7419 defsubr (&Sprocess_inherit_coding_system_flag
);
7420 defsubr (&Slist_system_processes
);
7421 defsubr (&Sprocess_attributes
);