1 /* Asynchronous subprocess control for GNU Emacs.
3 Copyright (C) 1985-1988, 1993-1996, 1998-1999, 2001-2011
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/>. */
27 #include <sys/types.h> /* Some typedefs are used in sys/file.h. */
37 /* Only MS-DOS does not define `subprocesses'. */
40 #include <sys/socket.h>
42 #include <netinet/in.h>
43 #include <arpa/inet.h>
45 /* Are local (unix) sockets supported? */
46 #if defined (HAVE_SYS_UN_H)
47 #if !defined (AF_LOCAL) && defined (AF_UNIX)
48 #define AF_LOCAL AF_UNIX
51 #define HAVE_LOCAL_SOCKETS
56 #include <sys/ioctl.h>
57 #if defined (HAVE_NET_IF_H)
59 #endif /* HAVE_NET_IF_H */
61 #if defined (HAVE_IFADDRS_H)
62 /* Must be after net/if.h */
65 /* We only use structs from this header when we use getifaddrs. */
66 #if defined (HAVE_NET_IF_DL_H)
67 #include <net/if_dl.h>
77 #include <netinet/in.h>
78 #include <arpa/nameser.h>
90 #endif /* subprocesses */
97 #include "character.h"
101 #include "termhooks.h"
102 #include "termopts.h"
103 #include "commands.h"
104 #include "keyboard.h"
105 #include "blockinput.h"
106 #include "dispextern.h"
107 #include "composite.h"
109 #include "sysselect.h"
110 #include "syssignal.h"
116 #if defined (USE_GTK) || defined (HAVE_GCONF) || defined (HAVE_GSETTINGS)
117 #include "xgselect.h"
123 Lisp_Object Qeuid
, Qegid
, Qcomm
, Qstate
, Qppid
, Qpgrp
, Qsess
, Qttname
, Qtpgid
;
124 Lisp_Object Qminflt
, Qmajflt
, Qcminflt
, Qcmajflt
, Qutime
, Qstime
, Qcstime
;
125 Lisp_Object Qcutime
, Qpri
, Qnice
, Qthcount
, Qstart
, Qvsize
, Qrss
, Qargs
;
126 Lisp_Object Quser
, Qgroup
, Qetime
, Qpcpu
, Qpmem
, Qtime
, Qctime
;
127 Lisp_Object QCname
, QCtype
;
129 /* Non-zero if keyboard input is on hold, zero otherwise. */
131 static int kbd_is_on_hold
;
133 /* Nonzero means don't run process sentinels. This is used
135 int inhibit_sentinels
;
139 Lisp_Object Qprocessp
;
140 static Lisp_Object Qrun
, Qstop
, Qsignal
;
141 static Lisp_Object Qopen
, Qclosed
, Qconnect
, Qfailed
, Qlisten
;
143 static Lisp_Object Qipv4
, Qdatagram
, Qseqpacket
;
144 static Lisp_Object Qreal
, Qnetwork
, Qserial
;
146 static Lisp_Object Qipv6
;
148 static Lisp_Object QCport
, QCprocess
;
150 Lisp_Object QCbytesize
, QCstopbits
, QCparity
, Qodd
, Qeven
;
151 Lisp_Object QCflowcontrol
, Qhw
, Qsw
, QCsummary
;
152 static Lisp_Object QCbuffer
, QChost
, QCservice
;
153 static Lisp_Object QClocal
, QCremote
, QCcoding
;
154 static Lisp_Object QCserver
, QCnowait
, QCnoquery
, QCstop
;
155 static Lisp_Object QCsentinel
, QClog
, QCoptions
, QCplist
;
156 static Lisp_Object Qlast_nonmenu_event
;
157 /* QCfamily is declared and initialized in xfaces.c,
158 QCfilter in keyboard.c. */
159 extern Lisp_Object QCfamily
, QCfilter
;
161 /* Qexit is declared and initialized in eval.c. */
163 /* QCfamily is defined in xfaces.c. */
164 extern Lisp_Object QCfamily
;
165 /* QCfilter is defined in keyboard.c. */
166 extern Lisp_Object QCfilter
;
168 #define NETCONN_P(p) (EQ (XPROCESS (p)->type, Qnetwork))
169 #define NETCONN1_P(p) (EQ ((p)->type, Qnetwork))
170 #define SERIALCONN_P(p) (EQ (XPROCESS (p)->type, Qserial))
171 #define SERIALCONN1_P(p) (EQ ((p)->type, Qserial))
177 /* Number of events of change of status of a process. */
178 static int process_tick
;
179 /* Number of events for which the user or sentinel has been notified. */
180 static int update_tick
;
182 /* Define NON_BLOCKING_CONNECT if we can support non-blocking connects. */
184 /* Only W32 has this, it really means that select can't take write mask. */
185 #ifdef BROKEN_NON_BLOCKING_CONNECT
186 #undef NON_BLOCKING_CONNECT
187 #define SELECT_CANT_DO_WRITE_MASK
189 #ifndef NON_BLOCKING_CONNECT
191 #if defined (HAVE_GETPEERNAME) || defined (GNU_LINUX)
192 #if defined (O_NONBLOCK) || defined (O_NDELAY)
193 #if defined (EWOULDBLOCK) || defined (EINPROGRESS)
194 #define NON_BLOCKING_CONNECT
195 #endif /* EWOULDBLOCK || EINPROGRESS */
196 #endif /* O_NONBLOCK || O_NDELAY */
197 #endif /* HAVE_GETPEERNAME || GNU_LINUX */
198 #endif /* HAVE_SELECT */
199 #endif /* NON_BLOCKING_CONNECT */
200 #endif /* BROKEN_NON_BLOCKING_CONNECT */
202 /* Define DATAGRAM_SOCKETS if datagrams can be used safely on
203 this system. We need to read full packets, so we need a
204 "non-destructive" select. So we require either native select,
205 or emulation of select using FIONREAD. */
207 #ifdef BROKEN_DATAGRAM_SOCKETS
208 #undef DATAGRAM_SOCKETS
210 #ifndef DATAGRAM_SOCKETS
211 #if defined (HAVE_SELECT) || defined (FIONREAD)
212 #if defined (HAVE_SENDTO) && defined (HAVE_RECVFROM) && defined (EMSGSIZE)
213 #define DATAGRAM_SOCKETS
214 #endif /* HAVE_SENDTO && HAVE_RECVFROM && EMSGSIZE */
215 #endif /* HAVE_SELECT || FIONREAD */
216 #endif /* DATAGRAM_SOCKETS */
217 #endif /* BROKEN_DATAGRAM_SOCKETS */
219 #if defined HAVE_LOCAL_SOCKETS && defined DATAGRAM_SOCKETS
220 # define HAVE_SEQPACKET
223 #if !defined (ADAPTIVE_READ_BUFFERING) && !defined (NO_ADAPTIVE_READ_BUFFERING)
224 #ifdef EMACS_HAS_USECS
225 #define ADAPTIVE_READ_BUFFERING
229 #ifdef ADAPTIVE_READ_BUFFERING
230 #define READ_OUTPUT_DELAY_INCREMENT 10000
231 #define READ_OUTPUT_DELAY_MAX (READ_OUTPUT_DELAY_INCREMENT * 5)
232 #define READ_OUTPUT_DELAY_MAX_MAX (READ_OUTPUT_DELAY_INCREMENT * 7)
234 /* Number of processes which have a non-zero read_output_delay,
235 and therefore might be delayed for adaptive read buffering. */
237 static int process_output_delay_count
;
239 /* Non-zero if any process has non-nil read_output_skip. */
241 static int process_output_skip
;
244 #define process_output_delay_count 0
247 static Lisp_Object
Fget_process (Lisp_Object
);
248 static void create_process (Lisp_Object
, char **, Lisp_Object
);
250 static int keyboard_bit_set (SELECT_TYPE
*);
252 static void deactivate_process (Lisp_Object
);
253 static void status_notify (struct Lisp_Process
*);
254 static int read_process_output (Lisp_Object
, int);
255 static void create_pty (Lisp_Object
);
257 /* If we support a window system, turn on the code to poll periodically
258 to detect C-g. It isn't actually used when doing interrupt input. */
259 #if defined (HAVE_WINDOW_SYSTEM) && !defined (USE_ASYNC_EVENTS)
260 #define POLL_FOR_INPUT
263 static Lisp_Object
get_process (register Lisp_Object name
);
264 static void exec_sentinel (Lisp_Object proc
, Lisp_Object reason
);
266 /* Mask of bits indicating the descriptors that we wait for input on. */
268 static SELECT_TYPE input_wait_mask
;
270 /* Mask that excludes keyboard input descriptor(s). */
272 static SELECT_TYPE non_keyboard_wait_mask
;
274 /* Mask that excludes process input descriptor(s). */
276 static SELECT_TYPE non_process_wait_mask
;
278 /* Mask for selecting for write. */
280 static SELECT_TYPE write_mask
;
282 #ifdef NON_BLOCKING_CONNECT
283 /* Mask of bits indicating the descriptors that we wait for connect to
284 complete on. Once they complete, they are removed from this mask
285 and added to the input_wait_mask and non_keyboard_wait_mask. */
287 static SELECT_TYPE connect_wait_mask
;
289 /* Number of bits set in connect_wait_mask. */
290 static int num_pending_connects
;
291 #endif /* NON_BLOCKING_CONNECT */
293 /* The largest descriptor currently in use for a process object. */
294 static int max_process_desc
;
296 /* The largest descriptor currently in use for input. */
297 static int max_input_desc
;
299 /* Indexed by descriptor, gives the process (if any) for that descriptor */
300 static Lisp_Object chan_process
[MAXDESC
];
302 /* Alist of elements (NAME . PROCESS) */
303 static Lisp_Object Vprocess_alist
;
305 /* Buffered-ahead input char from process, indexed by channel.
306 -1 means empty (no char is buffered).
307 Used on sys V where the only way to tell if there is any
308 output from the process is to read at least one char.
309 Always -1 on systems that support FIONREAD. */
311 static int proc_buffered_char
[MAXDESC
];
313 /* Table of `struct coding-system' for each process. */
314 static struct coding_system
*proc_decode_coding_system
[MAXDESC
];
315 static struct coding_system
*proc_encode_coding_system
[MAXDESC
];
317 #ifdef DATAGRAM_SOCKETS
318 /* Table of `partner address' for datagram sockets. */
319 static struct sockaddr_and_len
{
322 } datagram_address
[MAXDESC
];
323 #define DATAGRAM_CHAN_P(chan) (datagram_address[chan].sa != 0)
324 #define DATAGRAM_CONN_P(proc) (PROCESSP (proc) && datagram_address[XPROCESS (proc)->infd].sa != 0)
326 #define DATAGRAM_CHAN_P(chan) (0)
327 #define DATAGRAM_CONN_P(proc) (0)
330 /* Maximum number of bytes to send to a pty without an eof. */
331 static int pty_max_bytes
;
335 static struct fd_callback_data
341 int condition
; /* mask of the defines above. */
342 } fd_callback_info
[MAXDESC
];
345 /* Add a file descriptor FD to be monitored for when read is possible.
346 When read is possible, call FUNC with argument DATA. */
349 add_read_fd (int fd
, fd_callback func
, void *data
)
351 xassert (fd
< MAXDESC
);
352 add_keyboard_wait_descriptor (fd
);
354 fd_callback_info
[fd
].func
= func
;
355 fd_callback_info
[fd
].data
= data
;
356 fd_callback_info
[fd
].condition
|= FOR_READ
;
359 /* Stop monitoring file descriptor FD for when read is possible. */
362 delete_read_fd (int fd
)
364 xassert (fd
< MAXDESC
);
365 delete_keyboard_wait_descriptor (fd
);
367 fd_callback_info
[fd
].condition
&= ~FOR_READ
;
368 if (fd_callback_info
[fd
].condition
== 0)
370 fd_callback_info
[fd
].func
= 0;
371 fd_callback_info
[fd
].data
= 0;
375 /* Add a file descriptor FD to be monitored for when write is possible.
376 When write is possible, call FUNC with argument DATA. */
379 add_write_fd (int fd
, fd_callback func
, void *data
)
381 xassert (fd
< MAXDESC
);
382 FD_SET (fd
, &write_mask
);
383 if (fd
> max_input_desc
)
386 fd_callback_info
[fd
].func
= func
;
387 fd_callback_info
[fd
].data
= data
;
388 fd_callback_info
[fd
].condition
|= FOR_WRITE
;
391 /* Stop monitoring file descriptor FD for when write is possible. */
394 delete_write_fd (int fd
)
396 int lim
= max_input_desc
;
398 xassert (fd
< MAXDESC
);
399 FD_CLR (fd
, &write_mask
);
400 fd_callback_info
[fd
].condition
&= ~FOR_WRITE
;
401 if (fd_callback_info
[fd
].condition
== 0)
403 fd_callback_info
[fd
].func
= 0;
404 fd_callback_info
[fd
].data
= 0;
406 if (fd
== max_input_desc
)
407 for (fd
= lim
; fd
>= 0; fd
--)
408 if (FD_ISSET (fd
, &input_wait_mask
) || FD_ISSET (fd
, &write_mask
))
418 /* Compute the Lisp form of the process status, p->status, from
419 the numeric status that was returned by `wait'. */
421 static Lisp_Object
status_convert (int);
424 update_status (struct Lisp_Process
*p
)
426 eassert (p
->raw_status_new
);
427 p
->status
= status_convert (p
->raw_status
);
428 p
->raw_status_new
= 0;
431 /* Convert a process status word in Unix format to
432 the list that we use internally. */
435 status_convert (int w
)
438 return Fcons (Qstop
, Fcons (make_number (WSTOPSIG (w
)), Qnil
));
439 else if (WIFEXITED (w
))
440 return Fcons (Qexit
, Fcons (make_number (WRETCODE (w
)),
441 WCOREDUMP (w
) ? Qt
: Qnil
));
442 else if (WIFSIGNALED (w
))
443 return Fcons (Qsignal
, Fcons (make_number (WTERMSIG (w
)),
444 WCOREDUMP (w
) ? Qt
: Qnil
));
449 /* Given a status-list, extract the three pieces of information
450 and store them individually through the three pointers. */
453 decode_status (Lisp_Object l
, Lisp_Object
*symbol
, int *code
, int *coredump
)
467 *code
= XFASTINT (XCAR (tem
));
469 *coredump
= !NILP (tem
);
473 /* Return a string describing a process status list. */
476 status_message (struct Lisp_Process
*p
)
478 Lisp_Object status
= p
->status
;
481 Lisp_Object string
, string2
;
483 decode_status (status
, &symbol
, &code
, &coredump
);
485 if (EQ (symbol
, Qsignal
) || EQ (symbol
, Qstop
))
488 synchronize_system_messages_locale ();
489 signame
= strsignal (code
);
491 string
= build_string ("unknown");
496 string
= make_unibyte_string (signame
, strlen (signame
));
497 if (! NILP (Vlocale_coding_system
))
498 string
= (code_convert_string_norecord
499 (string
, Vlocale_coding_system
, 0));
500 c1
= STRING_CHAR (SDATA (string
));
503 Faset (string
, make_number (0), make_number (c2
));
505 string2
= build_string (coredump
? " (core dumped)\n" : "\n");
506 return concat2 (string
, string2
);
508 else if (EQ (symbol
, Qexit
))
511 return build_string (code
== 0 ? "deleted\n" : "connection broken by remote peer\n");
513 return build_string ("finished\n");
514 string
= Fnumber_to_string (make_number (code
));
515 string2
= build_string (coredump
? " (core dumped)\n" : "\n");
516 return concat3 (build_string ("exited abnormally with code "),
519 else if (EQ (symbol
, Qfailed
))
521 string
= Fnumber_to_string (make_number (code
));
522 string2
= build_string ("\n");
523 return concat3 (build_string ("failed with code "),
527 return Fcopy_sequence (Fsymbol_name (symbol
));
532 /* The file name of the pty opened by allocate_pty. */
533 static char pty_name
[24];
535 /* Open an available pty, returning a file descriptor.
536 Return -1 on failure.
537 The file name of the terminal corresponding to the pty
538 is left in the variable pty_name. */
549 for (c
= FIRST_PTY_LETTER
; c
<= 'z'; c
++)
550 for (i
= 0; i
< 16; i
++)
553 #ifdef PTY_NAME_SPRINTF
556 sprintf (pty_name
, "/dev/pty%c%x", c
, i
);
557 #endif /* no PTY_NAME_SPRINTF */
561 #else /* no PTY_OPEN */
563 { /* Some systems name their pseudoterminals so that there are gaps in
564 the usual sequence - for example, on HP9000/S700 systems, there
565 are no pseudoterminals with names ending in 'f'. So we wait for
566 three failures in a row before deciding that we've reached the
568 int failed_count
= 0;
571 if (stat (pty_name
, &stb
) < 0)
574 if (failed_count
>= 3)
581 fd
= emacs_open (pty_name
, O_RDWR
| O_NONBLOCK
, 0);
583 fd
= emacs_open (pty_name
, O_RDWR
| O_NDELAY
, 0);
586 #endif /* no PTY_OPEN */
590 /* check to make certain that both sides are available
591 this avoids a nasty yet stupid bug in rlogins */
592 #ifdef PTY_TTY_NAME_SPRINTF
595 sprintf (pty_name
, "/dev/tty%c%x", c
, i
);
596 #endif /* no PTY_TTY_NAME_SPRINTF */
597 if (access (pty_name
, 6) != 0)
612 #endif /* HAVE_PTYS */
615 make_process (Lisp_Object name
)
617 register Lisp_Object val
, tem
, name1
;
618 register struct Lisp_Process
*p
;
619 char suffix
[sizeof "<>" + INT_STRLEN_BOUND (printmax_t
)];
622 p
= allocate_process ();
630 p
->raw_status_new
= 0;
632 p
->mark
= Fmake_marker ();
633 p
->kill_without_query
= 0;
635 #ifdef ADAPTIVE_READ_BUFFERING
636 p
->adaptive_read_buffering
= 0;
637 p
->read_output_delay
= 0;
638 p
->read_output_skip
= 0;
642 p
->gnutls_initstage
= GNUTLS_STAGE_EMPTY
;
643 p
->gnutls_log_level
= 0;
645 p
->gnutls_state
= NULL
;
646 p
->gnutls_x509_cred
= NULL
;
647 p
->gnutls_anon_cred
= NULL
;
650 /* If name is already in use, modify it until it is unused. */
655 tem
= Fget_process (name1
);
656 if (NILP (tem
)) break;
657 sprintf (suffix
, "<%"pMd
">", i
);
658 name1
= concat2 (name
, build_string (suffix
));
662 XSETPROCESS (val
, p
);
663 Vprocess_alist
= Fcons (Fcons (name
, val
), Vprocess_alist
);
668 remove_process (register Lisp_Object proc
)
670 register Lisp_Object pair
;
672 pair
= Frassq (proc
, Vprocess_alist
);
673 Vprocess_alist
= Fdelq (pair
, Vprocess_alist
);
675 deactivate_process (proc
);
679 DEFUN ("processp", Fprocessp
, Sprocessp
, 1, 1, 0,
680 doc
: /* Return t if OBJECT is a process. */)
683 return PROCESSP (object
) ? Qt
: Qnil
;
686 DEFUN ("get-process", Fget_process
, Sget_process
, 1, 1, 0,
687 doc
: /* Return the process named NAME, or nil if there is none. */)
688 (register Lisp_Object name
)
693 return Fcdr (Fassoc (name
, Vprocess_alist
));
696 /* This is how commands for the user decode process arguments. It
697 accepts a process, a process name, a buffer, a buffer name, or nil.
698 Buffers denote the first process in the buffer, and nil denotes the
702 get_process (register Lisp_Object name
)
704 register Lisp_Object proc
, obj
;
707 obj
= Fget_process (name
);
709 obj
= Fget_buffer (name
);
711 error ("Process %s does not exist", SDATA (name
));
713 else if (NILP (name
))
714 obj
= Fcurrent_buffer ();
718 /* Now obj should be either a buffer object or a process object.
722 proc
= Fget_buffer_process (obj
);
724 error ("Buffer %s has no process", SDATA (BVAR (XBUFFER (obj
), name
)));
736 /* Fdelete_process promises to immediately forget about the process, but in
737 reality, Emacs needs to remember those processes until they have been
738 treated by sigchld_handler; otherwise this handler would consider the
739 process as being synchronous and say that the synchronous process is
741 static Lisp_Object deleted_pid_list
;
744 DEFUN ("delete-process", Fdelete_process
, Sdelete_process
, 1, 1, 0,
745 doc
: /* Delete PROCESS: kill it and forget about it immediately.
746 PROCESS may be a process, a buffer, the name of a process or buffer, or
747 nil, indicating the current buffer's process. */)
748 (register Lisp_Object process
)
750 register struct Lisp_Process
*p
;
752 process
= get_process (process
);
753 p
= XPROCESS (process
);
755 p
->raw_status_new
= 0;
756 if (NETCONN1_P (p
) || SERIALCONN1_P (p
))
758 p
->status
= Fcons (Qexit
, Fcons (make_number (0), Qnil
));
759 p
->tick
= ++process_tick
;
761 redisplay_preserve_echo_area (13);
763 else if (p
->infd
>= 0)
769 /* No problem storing the pid here, as it is still in Vprocess_alist. */
770 deleted_pid_list
= Fcons (make_fixnum_or_float (pid
),
771 /* GC treated elements set to nil. */
772 Fdelq (Qnil
, deleted_pid_list
));
773 /* If the process has already signaled, remove it from the list. */
774 if (p
->raw_status_new
)
777 if (CONSP (p
->status
))
778 symbol
= XCAR (p
->status
);
779 if (EQ (symbol
, Qsignal
) || EQ (symbol
, Qexit
))
781 = Fdelete (make_fixnum_or_float (pid
), deleted_pid_list
);
785 Fkill_process (process
, Qnil
);
786 /* Do this now, since remove_process will make sigchld_handler do nothing. */
788 = Fcons (Qsignal
, Fcons (make_number (SIGKILL
), Qnil
));
789 p
->tick
= ++process_tick
;
791 redisplay_preserve_echo_area (13);
794 remove_process (process
);
798 DEFUN ("process-status", Fprocess_status
, Sprocess_status
, 1, 1, 0,
799 doc
: /* Return the status of PROCESS.
800 The returned value is one of the following symbols:
801 run -- for a process that is running.
802 stop -- for a process stopped but continuable.
803 exit -- for a process that has exited.
804 signal -- for a process that has got a fatal signal.
805 open -- for a network stream connection that is open.
806 listen -- for a network stream server that is listening.
807 closed -- for a network stream connection that is closed.
808 connect -- when waiting for a non-blocking connection to complete.
809 failed -- when a non-blocking connection has failed.
810 nil -- if arg is a process name and no such process exists.
811 PROCESS may be a process, a buffer, the name of a process, or
812 nil, indicating the current buffer's process. */)
813 (register Lisp_Object process
)
815 register struct Lisp_Process
*p
;
816 register Lisp_Object status
;
818 if (STRINGP (process
))
819 process
= Fget_process (process
);
821 process
= get_process (process
);
826 p
= XPROCESS (process
);
827 if (p
->raw_status_new
)
831 status
= XCAR (status
);
832 if (NETCONN1_P (p
) || SERIALCONN1_P (p
))
834 if (EQ (status
, Qexit
))
836 else if (EQ (p
->command
, Qt
))
838 else if (EQ (status
, Qrun
))
844 DEFUN ("process-exit-status", Fprocess_exit_status
, Sprocess_exit_status
,
846 doc
: /* Return the exit status of PROCESS or the signal number that killed it.
847 If PROCESS has not yet exited or died, return 0. */)
848 (register Lisp_Object process
)
850 CHECK_PROCESS (process
);
851 if (XPROCESS (process
)->raw_status_new
)
852 update_status (XPROCESS (process
));
853 if (CONSP (XPROCESS (process
)->status
))
854 return XCAR (XCDR (XPROCESS (process
)->status
));
855 return make_number (0);
858 DEFUN ("process-id", Fprocess_id
, Sprocess_id
, 1, 1, 0,
859 doc
: /* Return the process id of PROCESS.
860 This is the pid of the external process which PROCESS uses or talks to.
861 For a network connection, this value is nil. */)
862 (register Lisp_Object process
)
866 CHECK_PROCESS (process
);
867 pid
= XPROCESS (process
)->pid
;
868 return (pid
? make_fixnum_or_float (pid
) : Qnil
);
871 DEFUN ("process-name", Fprocess_name
, Sprocess_name
, 1, 1, 0,
872 doc
: /* Return the name of PROCESS, as a string.
873 This is the name of the program invoked in PROCESS,
874 possibly modified to make it unique among process names. */)
875 (register Lisp_Object process
)
877 CHECK_PROCESS (process
);
878 return XPROCESS (process
)->name
;
881 DEFUN ("process-command", Fprocess_command
, Sprocess_command
, 1, 1, 0,
882 doc
: /* Return the command that was executed to start PROCESS.
883 This is a list of strings, the first string being the program executed
884 and the rest of the strings being the arguments given to it.
885 For a network or serial process, this is nil (process is running) or t
886 \(process is stopped). */)
887 (register Lisp_Object process
)
889 CHECK_PROCESS (process
);
890 return XPROCESS (process
)->command
;
893 DEFUN ("process-tty-name", Fprocess_tty_name
, Sprocess_tty_name
, 1, 1, 0,
894 doc
: /* Return the name of the terminal PROCESS uses, or nil if none.
895 This is the terminal that the process itself reads and writes on,
896 not the name of the pty that Emacs uses to talk with that terminal. */)
897 (register Lisp_Object process
)
899 CHECK_PROCESS (process
);
900 return XPROCESS (process
)->tty_name
;
903 DEFUN ("set-process-buffer", Fset_process_buffer
, Sset_process_buffer
,
905 doc
: /* Set buffer associated with PROCESS to BUFFER (a buffer, or nil).
907 (register Lisp_Object process
, Lisp_Object buffer
)
909 struct Lisp_Process
*p
;
911 CHECK_PROCESS (process
);
913 CHECK_BUFFER (buffer
);
914 p
= XPROCESS (process
);
916 if (NETCONN1_P (p
) || SERIALCONN1_P (p
))
917 p
->childp
= Fplist_put (p
->childp
, QCbuffer
, buffer
);
918 setup_process_coding_systems (process
);
922 DEFUN ("process-buffer", Fprocess_buffer
, Sprocess_buffer
,
924 doc
: /* Return the buffer PROCESS is associated with.
925 Output from PROCESS is inserted in this buffer unless PROCESS has a filter. */)
926 (register Lisp_Object process
)
928 CHECK_PROCESS (process
);
929 return XPROCESS (process
)->buffer
;
932 DEFUN ("process-mark", Fprocess_mark
, Sprocess_mark
,
934 doc
: /* Return the marker for the end of the last output from PROCESS. */)
935 (register Lisp_Object process
)
937 CHECK_PROCESS (process
);
938 return XPROCESS (process
)->mark
;
941 DEFUN ("set-process-filter", Fset_process_filter
, Sset_process_filter
,
943 doc
: /* Give PROCESS the filter function FILTER; nil means no filter.
944 A value of t means stop accepting output from the process.
946 When a process has a filter, its buffer is not used for output.
947 Instead, each time it does output, the entire string of output is
948 passed to the filter.
950 The filter gets two arguments: the process and the string of output.
951 The string argument is normally a multibyte string, except:
952 - if the process' input coding system is no-conversion or raw-text,
953 it is a unibyte string (the non-converted input), or else
954 - if `default-enable-multibyte-characters' is nil, it is a unibyte
955 string (the result of converting the decoded input multibyte
956 string to unibyte with `string-make-unibyte'). */)
957 (register Lisp_Object process
, Lisp_Object filter
)
959 struct Lisp_Process
*p
;
961 CHECK_PROCESS (process
);
962 p
= XPROCESS (process
);
964 /* Don't signal an error if the process' input file descriptor
965 is closed. This could make debugging Lisp more difficult,
966 for example when doing something like
968 (setq process (start-process ...))
970 (set-process-filter process ...) */
974 if (EQ (filter
, Qt
) && !EQ (p
->status
, Qlisten
))
976 FD_CLR (p
->infd
, &input_wait_mask
);
977 FD_CLR (p
->infd
, &non_keyboard_wait_mask
);
979 else if (EQ (p
->filter
, Qt
)
980 /* Network or serial process not stopped: */
981 && !EQ (p
->command
, Qt
))
983 FD_SET (p
->infd
, &input_wait_mask
);
984 FD_SET (p
->infd
, &non_keyboard_wait_mask
);
989 if (NETCONN1_P (p
) || SERIALCONN1_P (p
))
990 p
->childp
= Fplist_put (p
->childp
, QCfilter
, filter
);
991 setup_process_coding_systems (process
);
995 DEFUN ("process-filter", Fprocess_filter
, Sprocess_filter
,
997 doc
: /* Returns the filter function of PROCESS; nil if none.
998 See `set-process-filter' for more info on filter functions. */)
999 (register Lisp_Object process
)
1001 CHECK_PROCESS (process
);
1002 return XPROCESS (process
)->filter
;
1005 DEFUN ("set-process-sentinel", Fset_process_sentinel
, Sset_process_sentinel
,
1007 doc
: /* Give PROCESS the sentinel SENTINEL; nil for none.
1008 The sentinel is called as a function when the process changes state.
1009 It gets two arguments: the process, and a string describing the change. */)
1010 (register Lisp_Object process
, Lisp_Object sentinel
)
1012 struct Lisp_Process
*p
;
1014 CHECK_PROCESS (process
);
1015 p
= XPROCESS (process
);
1017 p
->sentinel
= sentinel
;
1018 if (NETCONN1_P (p
) || SERIALCONN1_P (p
))
1019 p
->childp
= Fplist_put (p
->childp
, QCsentinel
, sentinel
);
1023 DEFUN ("process-sentinel", Fprocess_sentinel
, Sprocess_sentinel
,
1025 doc
: /* Return the sentinel of PROCESS; nil if none.
1026 See `set-process-sentinel' for more info on sentinels. */)
1027 (register Lisp_Object process
)
1029 CHECK_PROCESS (process
);
1030 return XPROCESS (process
)->sentinel
;
1033 DEFUN ("set-process-window-size", Fset_process_window_size
,
1034 Sset_process_window_size
, 3, 3, 0,
1035 doc
: /* Tell PROCESS that it has logical window size HEIGHT and WIDTH. */)
1036 (register Lisp_Object process
, Lisp_Object height
, Lisp_Object width
)
1038 CHECK_PROCESS (process
);
1039 CHECK_RANGED_INTEGER (0, height
, INT_MAX
);
1040 CHECK_RANGED_INTEGER (0, width
, INT_MAX
);
1042 if (XPROCESS (process
)->infd
< 0
1043 || set_window_size (XPROCESS (process
)->infd
,
1044 XINT (height
), XINT (width
)) <= 0)
1050 DEFUN ("set-process-inherit-coding-system-flag",
1051 Fset_process_inherit_coding_system_flag
,
1052 Sset_process_inherit_coding_system_flag
, 2, 2, 0,
1053 doc
: /* Determine whether buffer of PROCESS will inherit coding-system.
1054 If the second argument FLAG is non-nil, then the variable
1055 `buffer-file-coding-system' of the buffer associated with PROCESS
1056 will be bound to the value of the coding system used to decode
1059 This is useful when the coding system specified for the process buffer
1060 leaves either the character code conversion or the end-of-line conversion
1061 unspecified, or if the coding system used to decode the process output
1062 is more appropriate for saving the process buffer.
1064 Binding the variable `inherit-process-coding-system' to non-nil before
1065 starting the process is an alternative way of setting the inherit flag
1066 for the process which will run. */)
1067 (register Lisp_Object process
, Lisp_Object flag
)
1069 CHECK_PROCESS (process
);
1070 XPROCESS (process
)->inherit_coding_system_flag
= !NILP (flag
);
1074 DEFUN ("set-process-query-on-exit-flag",
1075 Fset_process_query_on_exit_flag
, Sset_process_query_on_exit_flag
,
1077 doc
: /* Specify if query is needed for PROCESS when Emacs is exited.
1078 If the second argument FLAG is non-nil, Emacs will query the user before
1079 exiting or killing a buffer if PROCESS is running. */)
1080 (register Lisp_Object process
, Lisp_Object flag
)
1082 CHECK_PROCESS (process
);
1083 XPROCESS (process
)->kill_without_query
= NILP (flag
);
1087 DEFUN ("process-query-on-exit-flag",
1088 Fprocess_query_on_exit_flag
, Sprocess_query_on_exit_flag
,
1090 doc
: /* Return the current value of query-on-exit flag for PROCESS. */)
1091 (register Lisp_Object process
)
1093 CHECK_PROCESS (process
);
1094 return (XPROCESS (process
)->kill_without_query
? Qnil
: Qt
);
1097 #ifdef DATAGRAM_SOCKETS
1098 static Lisp_Object
Fprocess_datagram_address (Lisp_Object
);
1101 DEFUN ("process-contact", Fprocess_contact
, Sprocess_contact
,
1103 doc
: /* Return the contact info of PROCESS; t for a real child.
1104 For a network or serial connection, the value depends on the optional
1105 KEY arg. If KEY is nil, value is a cons cell of the form (HOST
1106 SERVICE) for a network connection or (PORT SPEED) for a serial
1107 connection. If KEY is t, the complete contact information for the
1108 connection is returned, else the specific value for the keyword KEY is
1109 returned. See `make-network-process' or `make-serial-process' for a
1110 list of keywords. */)
1111 (register Lisp_Object process
, Lisp_Object key
)
1113 Lisp_Object contact
;
1115 CHECK_PROCESS (process
);
1116 contact
= XPROCESS (process
)->childp
;
1118 #ifdef DATAGRAM_SOCKETS
1119 if (DATAGRAM_CONN_P (process
)
1120 && (EQ (key
, Qt
) || EQ (key
, QCremote
)))
1121 contact
= Fplist_put (contact
, QCremote
,
1122 Fprocess_datagram_address (process
));
1125 if ((!NETCONN_P (process
) && !SERIALCONN_P (process
)) || EQ (key
, Qt
))
1127 if (NILP (key
) && NETCONN_P (process
))
1128 return Fcons (Fplist_get (contact
, QChost
),
1129 Fcons (Fplist_get (contact
, QCservice
), Qnil
));
1130 if (NILP (key
) && SERIALCONN_P (process
))
1131 return Fcons (Fplist_get (contact
, QCport
),
1132 Fcons (Fplist_get (contact
, QCspeed
), Qnil
));
1133 return Fplist_get (contact
, key
);
1136 DEFUN ("process-plist", Fprocess_plist
, Sprocess_plist
,
1138 doc
: /* Return the plist of PROCESS. */)
1139 (register Lisp_Object process
)
1141 CHECK_PROCESS (process
);
1142 return XPROCESS (process
)->plist
;
1145 DEFUN ("set-process-plist", Fset_process_plist
, Sset_process_plist
,
1147 doc
: /* Replace the plist of PROCESS with PLIST. Returns PLIST. */)
1148 (register Lisp_Object process
, Lisp_Object plist
)
1150 CHECK_PROCESS (process
);
1153 XPROCESS (process
)->plist
= plist
;
1157 #if 0 /* Turned off because we don't currently record this info
1158 in the process. Perhaps add it. */
1159 DEFUN ("process-connection", Fprocess_connection
, Sprocess_connection
, 1, 1, 0,
1160 doc
: /* Return the connection type of PROCESS.
1161 The value is nil for a pipe, t or `pty' for a pty, or `stream' for
1162 a socket connection. */)
1163 (Lisp_Object process
)
1165 return XPROCESS (process
)->type
;
1169 DEFUN ("process-type", Fprocess_type
, Sprocess_type
, 1, 1, 0,
1170 doc
: /* Return the connection type of PROCESS.
1171 The value is either the symbol `real', `network', or `serial'.
1172 PROCESS may be a process, a buffer, the name of a process or buffer, or
1173 nil, indicating the current buffer's process. */)
1174 (Lisp_Object process
)
1177 proc
= get_process (process
);
1178 return XPROCESS (proc
)->type
;
1181 DEFUN ("format-network-address", Fformat_network_address
, Sformat_network_address
,
1183 doc
: /* Convert network ADDRESS from internal format to a string.
1184 A 4 or 5 element vector represents an IPv4 address (with port number).
1185 An 8 or 9 element vector represents an IPv6 address (with port number).
1186 If optional second argument OMIT-PORT is non-nil, don't include a port
1187 number in the string, even when present in ADDRESS.
1188 Returns nil if format of ADDRESS is invalid. */)
1189 (Lisp_Object address
, Lisp_Object omit_port
)
1194 if (STRINGP (address
)) /* AF_LOCAL */
1197 if (VECTORP (address
)) /* AF_INET or AF_INET6 */
1199 register struct Lisp_Vector
*p
= XVECTOR (address
);
1200 ptrdiff_t size
= p
->header
.size
;
1201 Lisp_Object args
[10];
1204 if (size
== 4 || (size
== 5 && !NILP (omit_port
)))
1206 args
[0] = build_string ("%d.%d.%d.%d");
1211 args
[0] = build_string ("%d.%d.%d.%d:%d");
1214 else if (size
== 8 || (size
== 9 && !NILP (omit_port
)))
1216 args
[0] = build_string ("%x:%x:%x:%x:%x:%x:%x:%x");
1221 args
[0] = build_string ("[%x:%x:%x:%x:%x:%x:%x:%x]:%d");
1227 for (i
= 0; i
< nargs
; i
++)
1229 if (! RANGED_INTEGERP (0, p
->contents
[i
], 65535))
1232 if (nargs
<= 5 /* IPv4 */
1233 && i
< 4 /* host, not port */
1234 && XINT (p
->contents
[i
]) > 255)
1237 args
[i
+1] = p
->contents
[i
];
1240 return Fformat (nargs
+1, args
);
1243 if (CONSP (address
))
1245 Lisp_Object args
[2];
1246 args
[0] = build_string ("<Family %d>");
1247 args
[1] = Fcar (address
);
1248 return Fformat (2, args
);
1254 DEFUN ("process-list", Fprocess_list
, Sprocess_list
, 0, 0, 0,
1255 doc
: /* Return a list of all processes. */)
1258 return Fmapcar (Qcdr
, Vprocess_alist
);
1261 /* Starting asynchronous inferior processes. */
1263 static Lisp_Object
start_process_unwind (Lisp_Object proc
);
1265 DEFUN ("start-process", Fstart_process
, Sstart_process
, 3, MANY
, 0,
1266 doc
: /* Start a program in a subprocess. Return the process object for it.
1267 NAME is name for process. It is modified if necessary to make it unique.
1268 BUFFER is the buffer (or buffer name) to associate with the process.
1270 Process output (both standard output and standard error streams) goes
1271 at end of BUFFER, unless you specify an output stream or filter
1272 function to handle the output. BUFFER may also be nil, meaning that
1273 this process is not associated with any buffer.
1275 PROGRAM is the program file name. It is searched for in `exec-path'
1276 (which see). If nil, just associate a pty with the buffer. Remaining
1277 arguments are strings to give program as arguments.
1279 If you want to separate standard output from standard error, invoke
1280 the command through a shell and redirect one of them using the shell
1283 usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS) */)
1284 (ptrdiff_t nargs
, Lisp_Object
*args
)
1286 Lisp_Object buffer
, name
, program
, proc
, current_dir
, tem
;
1287 register unsigned char **new_argv
;
1289 ptrdiff_t count
= SPECPDL_INDEX ();
1293 buffer
= Fget_buffer_create (buffer
);
1295 /* Make sure that the child will be able to chdir to the current
1296 buffer's current directory, or its unhandled equivalent. We
1297 can't just have the child check for an error when it does the
1298 chdir, since it's in a vfork.
1300 We have to GCPRO around this because Fexpand_file_name and
1301 Funhandled_file_name_directory might call a file name handling
1302 function. The argument list is protected by the caller, so all
1303 we really have to worry about is buffer. */
1305 struct gcpro gcpro1
, gcpro2
;
1307 current_dir
= BVAR (current_buffer
, directory
);
1309 GCPRO2 (buffer
, current_dir
);
1311 current_dir
= Funhandled_file_name_directory (current_dir
);
1312 if (NILP (current_dir
))
1313 /* If the file name handler says that current_dir is unreachable, use
1314 a sensible default. */
1315 current_dir
= build_string ("~/");
1316 current_dir
= expand_and_dir_to_file (current_dir
, Qnil
);
1317 if (NILP (Ffile_accessible_directory_p (current_dir
)))
1318 report_file_error ("Setting current directory",
1319 Fcons (BVAR (current_buffer
, directory
), Qnil
));
1325 CHECK_STRING (name
);
1329 if (!NILP (program
))
1330 CHECK_STRING (program
);
1332 proc
= make_process (name
);
1333 /* If an error occurs and we can't start the process, we want to
1334 remove it from the process list. This means that each error
1335 check in create_process doesn't need to call remove_process
1336 itself; it's all taken care of here. */
1337 record_unwind_protect (start_process_unwind
, proc
);
1339 XPROCESS (proc
)->childp
= Qt
;
1340 XPROCESS (proc
)->plist
= Qnil
;
1341 XPROCESS (proc
)->type
= Qreal
;
1342 XPROCESS (proc
)->buffer
= buffer
;
1343 XPROCESS (proc
)->sentinel
= Qnil
;
1344 XPROCESS (proc
)->filter
= Qnil
;
1345 XPROCESS (proc
)->command
= Flist (nargs
- 2, args
+ 2);
1348 /* AKA GNUTLS_INITSTAGE(proc). */
1349 XPROCESS (proc
)->gnutls_initstage
= GNUTLS_STAGE_EMPTY
;
1350 XPROCESS (proc
)->gnutls_cred_type
= Qnil
;
1353 #ifdef ADAPTIVE_READ_BUFFERING
1354 XPROCESS (proc
)->adaptive_read_buffering
1355 = (NILP (Vprocess_adaptive_read_buffering
) ? 0
1356 : EQ (Vprocess_adaptive_read_buffering
, Qt
) ? 1 : 2);
1359 /* Make the process marker point into the process buffer (if any). */
1360 if (BUFFERP (buffer
))
1361 set_marker_both (XPROCESS (proc
)->mark
, buffer
,
1362 BUF_ZV (XBUFFER (buffer
)),
1363 BUF_ZV_BYTE (XBUFFER (buffer
)));
1366 /* Decide coding systems for communicating with the process. Here
1367 we don't setup the structure coding_system nor pay attention to
1368 unibyte mode. They are done in create_process. */
1370 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
1371 Lisp_Object coding_systems
= Qt
;
1372 Lisp_Object val
, *args2
;
1373 struct gcpro gcpro1
, gcpro2
;
1375 val
= Vcoding_system_for_read
;
1378 args2
= (Lisp_Object
*) alloca ((nargs
+ 1) * sizeof *args2
);
1379 args2
[0] = Qstart_process
;
1380 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
1381 GCPRO2 (proc
, current_dir
);
1382 if (!NILP (program
))
1383 coding_systems
= Ffind_operation_coding_system (nargs
+ 1, args2
);
1385 if (CONSP (coding_systems
))
1386 val
= XCAR (coding_systems
);
1387 else if (CONSP (Vdefault_process_coding_system
))
1388 val
= XCAR (Vdefault_process_coding_system
);
1390 XPROCESS (proc
)->decode_coding_system
= val
;
1392 val
= Vcoding_system_for_write
;
1395 if (EQ (coding_systems
, Qt
))
1397 args2
= (Lisp_Object
*) alloca ((nargs
+ 1) * sizeof *args2
);
1398 args2
[0] = Qstart_process
;
1399 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
1400 GCPRO2 (proc
, current_dir
);
1401 if (!NILP (program
))
1402 coding_systems
= Ffind_operation_coding_system (nargs
+ 1, args2
);
1405 if (CONSP (coding_systems
))
1406 val
= XCDR (coding_systems
);
1407 else if (CONSP (Vdefault_process_coding_system
))
1408 val
= XCDR (Vdefault_process_coding_system
);
1410 XPROCESS (proc
)->encode_coding_system
= val
;
1411 /* Note: At this momemnt, the above coding system may leave
1412 text-conversion or eol-conversion unspecified. They will be
1413 decided after we read output from the process and decode it by
1414 some coding system, or just before we actually send a text to
1419 XPROCESS (proc
)->decoding_buf
= empty_unibyte_string
;
1420 XPROCESS (proc
)->decoding_carryover
= 0;
1421 XPROCESS (proc
)->encoding_buf
= empty_unibyte_string
;
1423 XPROCESS (proc
)->inherit_coding_system_flag
1424 = !(NILP (buffer
) || !inherit_process_coding_system
);
1426 if (!NILP (program
))
1428 /* If program file name is not absolute, search our path for it.
1429 Put the name we will really use in TEM. */
1430 if (!IS_DIRECTORY_SEP (SREF (program
, 0))
1431 && !(SCHARS (program
) > 1
1432 && IS_DEVICE_SEP (SREF (program
, 1))))
1434 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1437 GCPRO4 (name
, program
, buffer
, current_dir
);
1438 openp (Vexec_path
, program
, Vexec_suffixes
, &tem
, make_number (X_OK
));
1441 report_file_error ("Searching for program", Fcons (program
, Qnil
));
1442 tem
= Fexpand_file_name (tem
, Qnil
);
1446 if (!NILP (Ffile_directory_p (program
)))
1447 error ("Specified program for new process is a directory");
1451 /* If program file name starts with /: for quoting a magic name,
1453 if (SBYTES (tem
) > 2 && SREF (tem
, 0) == '/'
1454 && SREF (tem
, 1) == ':')
1455 tem
= Fsubstring (tem
, make_number (2), Qnil
);
1458 Lisp_Object arg_encoding
= Qnil
;
1459 struct gcpro gcpro1
;
1462 /* Encode the file name and put it in NEW_ARGV.
1463 That's where the child will use it to execute the program. */
1464 tem
= Fcons (ENCODE_FILE (tem
), Qnil
);
1466 /* Here we encode arguments by the coding system used for sending
1467 data to the process. We don't support using different coding
1468 systems for encoding arguments and for encoding data sent to the
1471 for (i
= 3; i
< nargs
; i
++)
1473 tem
= Fcons (args
[i
], tem
);
1474 CHECK_STRING (XCAR (tem
));
1475 if (STRING_MULTIBYTE (XCAR (tem
)))
1477 if (NILP (arg_encoding
))
1478 arg_encoding
= (complement_process_encoding_system
1479 (XPROCESS (proc
)->encode_coding_system
));
1481 code_convert_string_norecord
1482 (XCAR (tem
), arg_encoding
, 1));
1489 /* Now that everything is encoded we can collect the strings into
1491 new_argv
= (unsigned char **) alloca ((nargs
- 1) * sizeof (char *));
1492 new_argv
[nargs
- 2] = 0;
1494 for (i
= nargs
- 2; i
-- != 0; )
1496 new_argv
[i
] = SDATA (XCAR (tem
));
1500 create_process (proc
, (char **) new_argv
, current_dir
);
1505 return unbind_to (count
, proc
);
1508 /* This function is the unwind_protect form for Fstart_process. If
1509 PROC doesn't have its pid set, then we know someone has signaled
1510 an error and the process wasn't started successfully, so we should
1511 remove it from the process list. */
1513 start_process_unwind (Lisp_Object proc
)
1515 if (!PROCESSP (proc
))
1518 /* Was PROC started successfully? */
1519 if (XPROCESS (proc
)->pid
== -1)
1520 remove_process (proc
);
1526 create_process_1 (struct atimer
*timer
)
1528 /* Nothing to do. */
1533 create_process (Lisp_Object process
, char **new_argv
, Lisp_Object current_dir
)
1535 int inchannel
, outchannel
;
1538 #if !defined (WINDOWSNT) && defined (FD_CLOEXEC)
1539 int wait_child_setup
[2];
1543 struct sigaction sigint_action
;
1544 struct sigaction sigquit_action
;
1545 struct sigaction sigpipe_action
;
1547 struct sigaction sighup_action
;
1549 /* Use volatile to protect variables from being clobbered by longjmp. */
1550 volatile int forkin
, forkout
;
1551 volatile int pty_flag
= 0;
1553 extern char **environ
;
1556 inchannel
= outchannel
= -1;
1559 if (!NILP (Vprocess_connection_type
))
1560 outchannel
= inchannel
= allocate_pty ();
1564 #if ! defined (USG) || defined (USG_SUBTTY_WORKS)
1565 /* On most USG systems it does not work to open the pty's tty here,
1566 then close it and reopen it in the child. */
1568 /* Don't let this terminal become our controlling terminal
1569 (in case we don't have one). */
1570 forkout
= forkin
= emacs_open (pty_name
, O_RDWR
| O_NOCTTY
, 0);
1572 forkout
= forkin
= emacs_open (pty_name
, O_RDWR
, 0);
1575 report_file_error ("Opening pty", Qnil
);
1577 forkin
= forkout
= -1;
1578 #endif /* not USG, or USG_SUBTTY_WORKS */
1582 #endif /* HAVE_PTYS */
1587 report_file_error ("Creating pipe", Qnil
);
1593 emacs_close (inchannel
);
1594 emacs_close (forkout
);
1595 report_file_error ("Creating pipe", Qnil
);
1601 #if !defined (WINDOWSNT) && defined (FD_CLOEXEC)
1605 tem
= pipe (wait_child_setup
);
1607 report_file_error ("Creating pipe", Qnil
);
1608 tem
= fcntl (wait_child_setup
[1], F_GETFD
, 0);
1610 tem
= fcntl (wait_child_setup
[1], F_SETFD
, tem
| FD_CLOEXEC
);
1613 emacs_close (wait_child_setup
[0]);
1614 emacs_close (wait_child_setup
[1]);
1615 report_file_error ("Setting file descriptor flags", Qnil
);
1621 fcntl (inchannel
, F_SETFL
, O_NONBLOCK
);
1622 fcntl (outchannel
, F_SETFL
, O_NONBLOCK
);
1625 fcntl (inchannel
, F_SETFL
, O_NDELAY
);
1626 fcntl (outchannel
, F_SETFL
, O_NDELAY
);
1630 /* Record this as an active process, with its channels.
1631 As a result, child_setup will close Emacs's side of the pipes. */
1632 chan_process
[inchannel
] = process
;
1633 XPROCESS (process
)->infd
= inchannel
;
1634 XPROCESS (process
)->outfd
= outchannel
;
1636 /* Previously we recorded the tty descriptor used in the subprocess.
1637 It was only used for getting the foreground tty process, so now
1638 we just reopen the device (see emacs_get_tty_pgrp) as this is
1639 more portable (see USG_SUBTTY_WORKS above). */
1641 XPROCESS (process
)->pty_flag
= pty_flag
;
1642 XPROCESS (process
)->status
= Qrun
;
1644 /* Delay interrupts until we have a chance to store
1645 the new fork's pid in its process structure */
1646 sigemptyset (&blocked
);
1648 sigaddset (&blocked
, SIGCHLD
);
1650 #ifdef HAVE_WORKING_VFORK
1651 /* On many hosts (e.g. Solaris 2.4), if a vforked child calls `signal',
1652 this sets the parent's signal handlers as well as the child's.
1653 So delay all interrupts whose handlers the child might munge,
1654 and record the current handlers so they can be restored later. */
1655 sigaddset (&blocked
, SIGINT
); sigaction (SIGINT
, 0, &sigint_action
);
1656 sigaddset (&blocked
, SIGQUIT
); sigaction (SIGQUIT
, 0, &sigquit_action
);
1657 sigaddset (&blocked
, SIGPIPE
); sigaction (SIGPIPE
, 0, &sigpipe_action
);
1659 sigaddset (&blocked
, SIGHUP
); sigaction (SIGHUP
, 0, &sighup_action
);
1661 #endif /* HAVE_WORKING_VFORK */
1662 pthread_sigmask (SIG_BLOCK
, &blocked
, &procmask
);
1664 FD_SET (inchannel
, &input_wait_mask
);
1665 FD_SET (inchannel
, &non_keyboard_wait_mask
);
1666 if (inchannel
> max_process_desc
)
1667 max_process_desc
= inchannel
;
1669 /* Until we store the proper pid, enable sigchld_handler
1670 to recognize an unknown pid as standing for this process.
1671 It is very important not to let this `marker' value stay
1672 in the table after this function has returned; if it does
1673 it might cause call-process to hang and subsequent asynchronous
1674 processes to get their return values scrambled. */
1675 XPROCESS (process
)->pid
= -1;
1677 /* This must be called after the above line because it may signal an
1679 setup_process_coding_systems (process
);
1684 /* child_setup must clobber environ on systems with true vfork.
1685 Protect it from permanent change. */
1686 char **save_environ
= environ
;
1687 volatile Lisp_Object encoded_current_dir
= ENCODE_FILE (current_dir
);
1692 #endif /* not WINDOWSNT */
1694 int xforkin
= forkin
;
1695 int xforkout
= forkout
;
1697 #if 0 /* This was probably a mistake--it duplicates code later on,
1698 but fails to handle all the cases. */
1699 /* Make sure SIGCHLD is not blocked in the child. */
1700 sigsetmask (SIGEMPTYMASK
);
1703 /* Make the pty be the controlling terminal of the process. */
1705 /* First, disconnect its current controlling terminal. */
1707 /* We tried doing setsid only if pty_flag, but it caused
1708 process_set_signal to fail on SGI when using a pipe. */
1710 /* Make the pty's terminal the controlling terminal. */
1711 if (pty_flag
&& xforkin
>= 0)
1714 /* We ignore the return value
1715 because faith@cs.unc.edu says that is necessary on Linux. */
1716 ioctl (xforkin
, TIOCSCTTY
, 0);
1719 #else /* not HAVE_SETSID */
1721 /* It's very important to call setpgrp here and no time
1722 afterwards. Otherwise, we lose our controlling tty which
1723 is set when we open the pty. */
1726 #endif /* not HAVE_SETSID */
1727 #if defined (LDISC1)
1728 if (pty_flag
&& xforkin
>= 0)
1731 tcgetattr (xforkin
, &t
);
1733 if (tcsetattr (xforkin
, TCSANOW
, &t
) < 0)
1734 emacs_write (1, "create_process/tcsetattr LDISC1 failed\n", 39);
1737 #if defined (NTTYDISC) && defined (TIOCSETD)
1738 if (pty_flag
&& xforkin
>= 0)
1740 /* Use new line discipline. */
1741 int ldisc
= NTTYDISC
;
1742 ioctl (xforkin
, TIOCSETD
, &ldisc
);
1747 /* In 4.3BSD, the TIOCSPGRP bug has been fixed, and now you
1748 can do TIOCSPGRP only to the process's controlling tty. */
1751 /* I wonder: would just ioctl (0, TIOCNOTTY, 0) work here?
1752 I can't test it since I don't have 4.3. */
1753 int j
= emacs_open ("/dev/tty", O_RDWR
, 0);
1756 ioctl (j
, TIOCNOTTY
, 0);
1760 /* In order to get a controlling terminal on some versions
1761 of BSD, it is necessary to put the process in pgrp 0
1762 before it opens the terminal. */
1770 #endif /* TIOCNOTTY */
1772 #if !defined (DONT_REOPEN_PTY)
1773 /*** There is a suggestion that this ought to be a
1774 conditional on TIOCSPGRP,
1775 or !(defined (HAVE_SETSID) && defined (TIOCSCTTY)).
1776 Trying the latter gave the wrong results on Debian GNU/Linux 1.1;
1777 that system does seem to need this code, even though
1778 both HAVE_SETSID and TIOCSCTTY are defined. */
1779 /* Now close the pty (if we had it open) and reopen it.
1780 This makes the pty the controlling terminal of the subprocess. */
1784 /* I wonder if emacs_close (emacs_open (pty_name, ...))
1787 emacs_close (xforkin
);
1788 xforkout
= xforkin
= emacs_open (pty_name
, O_RDWR
, 0);
1792 emacs_write (1, "Couldn't open the pty terminal ", 31);
1793 emacs_write (1, pty_name
, strlen (pty_name
));
1794 emacs_write (1, "\n", 1);
1799 #endif /* not DONT_REOPEN_PTY */
1801 #ifdef SETUP_SLAVE_PTY
1806 #endif /* SETUP_SLAVE_PTY */
1808 /* On AIX, we've disabled SIGHUP above once we start a child on a pty.
1809 Now reenable it in the child, so it will die when we want it to. */
1811 signal (SIGHUP
, SIG_DFL
);
1813 #endif /* HAVE_PTYS */
1815 signal (SIGINT
, SIG_DFL
);
1816 signal (SIGQUIT
, SIG_DFL
);
1817 /* GConf causes us to ignore SIGPIPE, make sure it is restored
1819 signal (SIGPIPE
, SIG_DFL
);
1821 /* Stop blocking signals in the child. */
1822 pthread_sigmask (SIG_SETMASK
, &procmask
, 0);
1825 child_setup_tty (xforkout
);
1827 pid
= child_setup (xforkin
, xforkout
, xforkout
,
1828 new_argv
, 1, encoded_current_dir
);
1829 #else /* not WINDOWSNT */
1831 emacs_close (wait_child_setup
[0]);
1833 child_setup (xforkin
, xforkout
, xforkout
,
1834 new_argv
, 1, encoded_current_dir
);
1835 #endif /* not WINDOWSNT */
1837 environ
= save_environ
;
1842 /* This runs in the Emacs process. */
1846 emacs_close (forkin
);
1847 if (forkin
!= forkout
&& forkout
>= 0)
1848 emacs_close (forkout
);
1852 /* vfork succeeded. */
1853 XPROCESS (process
)->pid
= pid
;
1856 register_child (pid
, inchannel
);
1857 #endif /* WINDOWSNT */
1859 /* If the subfork execv fails, and it exits,
1860 this close hangs. I don't know why.
1861 So have an interrupt jar it loose. */
1863 struct atimer
*timer
;
1867 EMACS_SET_SECS_USECS (offset
, 1, 0);
1868 timer
= start_atimer (ATIMER_RELATIVE
, offset
, create_process_1
, 0);
1871 emacs_close (forkin
);
1873 cancel_atimer (timer
);
1877 if (forkin
!= forkout
&& forkout
>= 0)
1878 emacs_close (forkout
);
1882 XPROCESS (process
)->tty_name
= build_string (pty_name
);
1885 XPROCESS (process
)->tty_name
= Qnil
;
1887 #if !defined (WINDOWSNT) && defined (FD_CLOEXEC)
1888 /* Wait for child_setup to complete in case that vfork is
1889 actually defined as fork. The descriptor wait_child_setup[1]
1890 of a pipe is closed at the child side either by close-on-exec
1891 on successful execvp or the _exit call in child_setup. */
1895 emacs_close (wait_child_setup
[1]);
1896 emacs_read (wait_child_setup
[0], &dummy
, 1);
1897 emacs_close (wait_child_setup
[0]);
1902 /* Restore the signal state whether vfork succeeded or not.
1903 (We will signal an error, below, if it failed.) */
1904 #ifdef HAVE_WORKING_VFORK
1905 /* Restore the parent's signal handlers. */
1906 sigaction (SIGINT
, &sigint_action
, 0);
1907 sigaction (SIGQUIT
, &sigquit_action
, 0);
1908 sigaction (SIGPIPE
, &sigpipe_action
, 0);
1910 sigaction (SIGHUP
, &sighup_action
, 0);
1912 #endif /* HAVE_WORKING_VFORK */
1913 /* Stop blocking signals in the parent. */
1914 pthread_sigmask (SIG_SETMASK
, &procmask
, 0);
1916 /* Now generate the error if vfork failed. */
1918 report_file_error ("Doing vfork", Qnil
);
1922 create_pty (Lisp_Object process
)
1924 int inchannel
, outchannel
;
1927 inchannel
= outchannel
= -1;
1930 if (!NILP (Vprocess_connection_type
))
1931 outchannel
= inchannel
= allocate_pty ();
1935 #if ! defined (USG) || defined (USG_SUBTTY_WORKS)
1936 /* On most USG systems it does not work to open the pty's tty here,
1937 then close it and reopen it in the child. */
1939 /* Don't let this terminal become our controlling terminal
1940 (in case we don't have one). */
1941 int forkout
= emacs_open (pty_name
, O_RDWR
| O_NOCTTY
, 0);
1943 int forkout
= emacs_open (pty_name
, O_RDWR
, 0);
1946 report_file_error ("Opening pty", Qnil
);
1947 #if defined (DONT_REOPEN_PTY)
1948 /* In the case that vfork is defined as fork, the parent process
1949 (Emacs) may send some data before the child process completes
1950 tty options setup. So we setup tty before forking. */
1951 child_setup_tty (forkout
);
1952 #endif /* DONT_REOPEN_PTY */
1953 #endif /* not USG, or USG_SUBTTY_WORKS */
1956 #endif /* HAVE_PTYS */
1959 fcntl (inchannel
, F_SETFL
, O_NONBLOCK
);
1960 fcntl (outchannel
, F_SETFL
, O_NONBLOCK
);
1963 fcntl (inchannel
, F_SETFL
, O_NDELAY
);
1964 fcntl (outchannel
, F_SETFL
, O_NDELAY
);
1968 /* Record this as an active process, with its channels.
1969 As a result, child_setup will close Emacs's side of the pipes. */
1970 chan_process
[inchannel
] = process
;
1971 XPROCESS (process
)->infd
= inchannel
;
1972 XPROCESS (process
)->outfd
= outchannel
;
1974 /* Previously we recorded the tty descriptor used in the subprocess.
1975 It was only used for getting the foreground tty process, so now
1976 we just reopen the device (see emacs_get_tty_pgrp) as this is
1977 more portable (see USG_SUBTTY_WORKS above). */
1979 XPROCESS (process
)->pty_flag
= pty_flag
;
1980 XPROCESS (process
)->status
= Qrun
;
1981 setup_process_coding_systems (process
);
1983 FD_SET (inchannel
, &input_wait_mask
);
1984 FD_SET (inchannel
, &non_keyboard_wait_mask
);
1985 if (inchannel
> max_process_desc
)
1986 max_process_desc
= inchannel
;
1988 XPROCESS (process
)->pid
= -2;
1991 XPROCESS (process
)->tty_name
= build_string (pty_name
);
1994 XPROCESS (process
)->tty_name
= Qnil
;
1998 /* Convert an internal struct sockaddr to a lisp object (vector or string).
1999 The address family of sa is not included in the result. */
2002 conv_sockaddr_to_lisp (struct sockaddr
*sa
, int len
)
2004 Lisp_Object address
;
2007 register struct Lisp_Vector
*p
;
2009 /* Workaround for a bug in getsockname on BSD: Names bound to
2010 sockets in the UNIX domain are inaccessible; getsockname returns
2011 a zero length name. */
2012 if (len
< offsetof (struct sockaddr
, sa_family
) + sizeof (sa
->sa_family
))
2013 return empty_unibyte_string
;
2015 switch (sa
->sa_family
)
2019 struct sockaddr_in
*sin
= (struct sockaddr_in
*) sa
;
2020 len
= sizeof (sin
->sin_addr
) + 1;
2021 address
= Fmake_vector (make_number (len
), Qnil
);
2022 p
= XVECTOR (address
);
2023 p
->contents
[--len
] = make_number (ntohs (sin
->sin_port
));
2024 cp
= (unsigned char *) &sin
->sin_addr
;
2030 struct sockaddr_in6
*sin6
= (struct sockaddr_in6
*) sa
;
2031 uint16_t *ip6
= (uint16_t *) &sin6
->sin6_addr
;
2032 len
= sizeof (sin6
->sin6_addr
)/2 + 1;
2033 address
= Fmake_vector (make_number (len
), Qnil
);
2034 p
= XVECTOR (address
);
2035 p
->contents
[--len
] = make_number (ntohs (sin6
->sin6_port
));
2036 for (i
= 0; i
< len
; i
++)
2037 p
->contents
[i
] = make_number (ntohs (ip6
[i
]));
2041 #ifdef HAVE_LOCAL_SOCKETS
2044 struct sockaddr_un
*sockun
= (struct sockaddr_un
*) sa
;
2045 for (i
= 0; i
< sizeof (sockun
->sun_path
); i
++)
2046 if (sockun
->sun_path
[i
] == 0)
2048 return make_unibyte_string (sockun
->sun_path
, i
);
2052 len
-= offsetof (struct sockaddr
, sa_family
) + sizeof (sa
->sa_family
);
2053 address
= Fcons (make_number (sa
->sa_family
),
2054 Fmake_vector (make_number (len
), Qnil
));
2055 p
= XVECTOR (XCDR (address
));
2056 cp
= (unsigned char *) &sa
->sa_family
+ sizeof (sa
->sa_family
);
2062 p
->contents
[i
++] = make_number (*cp
++);
2068 /* Get family and required size for sockaddr structure to hold ADDRESS. */
2071 get_lisp_to_sockaddr_size (Lisp_Object address
, int *familyp
)
2073 register struct Lisp_Vector
*p
;
2075 if (VECTORP (address
))
2077 p
= XVECTOR (address
);
2078 if (p
->header
.size
== 5)
2081 return sizeof (struct sockaddr_in
);
2084 else if (p
->header
.size
== 9)
2086 *familyp
= AF_INET6
;
2087 return sizeof (struct sockaddr_in6
);
2091 #ifdef HAVE_LOCAL_SOCKETS
2092 else if (STRINGP (address
))
2094 *familyp
= AF_LOCAL
;
2095 return sizeof (struct sockaddr_un
);
2098 else if (CONSP (address
) && TYPE_RANGED_INTEGERP (int, XCAR (address
))
2099 && VECTORP (XCDR (address
)))
2101 struct sockaddr
*sa
;
2102 *familyp
= XINT (XCAR (address
));
2103 p
= XVECTOR (XCDR (address
));
2104 return p
->header
.size
+ sizeof (sa
->sa_family
);
2109 /* Convert an address object (vector or string) to an internal sockaddr.
2111 The address format has been basically validated by
2112 get_lisp_to_sockaddr_size, but this does not mean FAMILY is valid;
2113 it could have come from user data. So if FAMILY is not valid,
2114 we return after zeroing *SA. */
2117 conv_lisp_to_sockaddr (int family
, Lisp_Object address
, struct sockaddr
*sa
, int len
)
2119 register struct Lisp_Vector
*p
;
2120 register unsigned char *cp
= NULL
;
2124 memset (sa
, 0, len
);
2126 if (VECTORP (address
))
2128 p
= XVECTOR (address
);
2129 if (family
== AF_INET
)
2131 struct sockaddr_in
*sin
= (struct sockaddr_in
*) sa
;
2132 len
= sizeof (sin
->sin_addr
) + 1;
2133 hostport
= XINT (p
->contents
[--len
]);
2134 sin
->sin_port
= htons (hostport
);
2135 cp
= (unsigned char *)&sin
->sin_addr
;
2136 sa
->sa_family
= family
;
2139 else if (family
== AF_INET6
)
2141 struct sockaddr_in6
*sin6
= (struct sockaddr_in6
*) sa
;
2142 uint16_t *ip6
= (uint16_t *)&sin6
->sin6_addr
;
2143 len
= sizeof (sin6
->sin6_addr
) + 1;
2144 hostport
= XINT (p
->contents
[--len
]);
2145 sin6
->sin6_port
= htons (hostport
);
2146 for (i
= 0; i
< len
; i
++)
2147 if (INTEGERP (p
->contents
[i
]))
2149 int j
= XFASTINT (p
->contents
[i
]) & 0xffff;
2152 sa
->sa_family
= family
;
2159 else if (STRINGP (address
))
2161 #ifdef HAVE_LOCAL_SOCKETS
2162 if (family
== AF_LOCAL
)
2164 struct sockaddr_un
*sockun
= (struct sockaddr_un
*) sa
;
2165 cp
= SDATA (address
);
2166 for (i
= 0; i
< sizeof (sockun
->sun_path
) && *cp
; i
++)
2167 sockun
->sun_path
[i
] = *cp
++;
2168 sa
->sa_family
= family
;
2175 p
= XVECTOR (XCDR (address
));
2176 cp
= (unsigned char *)sa
+ sizeof (sa
->sa_family
);
2179 for (i
= 0; i
< len
; i
++)
2180 if (INTEGERP (p
->contents
[i
]))
2181 *cp
++ = XFASTINT (p
->contents
[i
]) & 0xff;
2184 #ifdef DATAGRAM_SOCKETS
2185 DEFUN ("process-datagram-address", Fprocess_datagram_address
, Sprocess_datagram_address
,
2187 doc
: /* Get the current datagram address associated with PROCESS. */)
2188 (Lisp_Object process
)
2192 CHECK_PROCESS (process
);
2194 if (!DATAGRAM_CONN_P (process
))
2197 channel
= XPROCESS (process
)->infd
;
2198 return conv_sockaddr_to_lisp (datagram_address
[channel
].sa
,
2199 datagram_address
[channel
].len
);
2202 DEFUN ("set-process-datagram-address", Fset_process_datagram_address
, Sset_process_datagram_address
,
2204 doc
: /* Set the datagram address for PROCESS to ADDRESS.
2205 Returns nil upon error setting address, ADDRESS otherwise. */)
2206 (Lisp_Object process
, Lisp_Object address
)
2211 CHECK_PROCESS (process
);
2213 if (!DATAGRAM_CONN_P (process
))
2216 channel
= XPROCESS (process
)->infd
;
2218 len
= get_lisp_to_sockaddr_size (address
, &family
);
2219 if (datagram_address
[channel
].len
!= len
)
2221 conv_lisp_to_sockaddr (family
, address
, datagram_address
[channel
].sa
, len
);
2227 static const struct socket_options
{
2228 /* The name of this option. Should be lowercase version of option
2229 name without SO_ prefix. */
2231 /* Option level SOL_... */
2233 /* Option number SO_... */
2235 enum { SOPT_UNKNOWN
, SOPT_BOOL
, SOPT_INT
, SOPT_IFNAME
, SOPT_LINGER
} opttype
;
2236 enum { OPIX_NONE
=0, OPIX_MISC
=1, OPIX_REUSEADDR
=2 } optbit
;
2237 } socket_options
[] =
2239 #ifdef SO_BINDTODEVICE
2240 { ":bindtodevice", SOL_SOCKET
, SO_BINDTODEVICE
, SOPT_IFNAME
, OPIX_MISC
},
2243 { ":broadcast", SOL_SOCKET
, SO_BROADCAST
, SOPT_BOOL
, OPIX_MISC
},
2246 { ":dontroute", SOL_SOCKET
, SO_DONTROUTE
, SOPT_BOOL
, OPIX_MISC
},
2249 { ":keepalive", SOL_SOCKET
, SO_KEEPALIVE
, SOPT_BOOL
, OPIX_MISC
},
2252 { ":linger", SOL_SOCKET
, SO_LINGER
, SOPT_LINGER
, OPIX_MISC
},
2255 { ":oobinline", SOL_SOCKET
, SO_OOBINLINE
, SOPT_BOOL
, OPIX_MISC
},
2258 { ":priority", SOL_SOCKET
, SO_PRIORITY
, SOPT_INT
, OPIX_MISC
},
2261 { ":reuseaddr", SOL_SOCKET
, SO_REUSEADDR
, SOPT_BOOL
, OPIX_REUSEADDR
},
2263 { 0, 0, 0, SOPT_UNKNOWN
, OPIX_NONE
}
2266 /* Set option OPT to value VAL on socket S.
2268 Returns (1<<socket_options[OPT].optbit) if option is known, 0 otherwise.
2269 Signals an error if setting a known option fails.
2273 set_socket_option (int s
, Lisp_Object opt
, Lisp_Object val
)
2276 const struct socket_options
*sopt
;
2281 name
= SSDATA (SYMBOL_NAME (opt
));
2282 for (sopt
= socket_options
; sopt
->name
; sopt
++)
2283 if (strcmp (name
, sopt
->name
) == 0)
2286 switch (sopt
->opttype
)
2291 optval
= NILP (val
) ? 0 : 1;
2292 ret
= setsockopt (s
, sopt
->optlevel
, sopt
->optnum
,
2293 &optval
, sizeof (optval
));
2300 if (TYPE_RANGED_INTEGERP (int, val
))
2301 optval
= XINT (val
);
2303 error ("Bad option value for %s", name
);
2304 ret
= setsockopt (s
, sopt
->optlevel
, sopt
->optnum
,
2305 &optval
, sizeof (optval
));
2309 #ifdef SO_BINDTODEVICE
2312 char devname
[IFNAMSIZ
+1];
2314 /* This is broken, at least in the Linux 2.4 kernel.
2315 To unbind, the arg must be a zero integer, not the empty string.
2316 This should work on all systems. KFS. 2003-09-23. */
2317 memset (devname
, 0, sizeof devname
);
2320 char *arg
= SSDATA (val
);
2321 int len
= min (strlen (arg
), IFNAMSIZ
);
2322 memcpy (devname
, arg
, len
);
2324 else if (!NILP (val
))
2325 error ("Bad option value for %s", name
);
2326 ret
= setsockopt (s
, sopt
->optlevel
, sopt
->optnum
,
2335 struct linger linger
;
2338 linger
.l_linger
= 0;
2339 if (TYPE_RANGED_INTEGERP (int, val
))
2340 linger
.l_linger
= XINT (val
);
2342 linger
.l_onoff
= NILP (val
) ? 0 : 1;
2343 ret
= setsockopt (s
, sopt
->optlevel
, sopt
->optnum
,
2344 &linger
, sizeof (linger
));
2354 report_file_error ("Cannot set network option",
2355 Fcons (opt
, Fcons (val
, Qnil
)));
2356 return (1 << sopt
->optbit
);
2360 DEFUN ("set-network-process-option",
2361 Fset_network_process_option
, Sset_network_process_option
,
2363 doc
: /* For network process PROCESS set option OPTION to value VALUE.
2364 See `make-network-process' for a list of options and values.
2365 If optional fourth arg NO-ERROR is non-nil, don't signal an error if
2366 OPTION is not a supported option, return nil instead; otherwise return t. */)
2367 (Lisp_Object process
, Lisp_Object option
, Lisp_Object value
, Lisp_Object no_error
)
2370 struct Lisp_Process
*p
;
2372 CHECK_PROCESS (process
);
2373 p
= XPROCESS (process
);
2374 if (!NETCONN1_P (p
))
2375 error ("Process is not a network process");
2379 error ("Process is not running");
2381 if (set_socket_option (s
, option
, value
))
2383 p
->childp
= Fplist_put (p
->childp
, option
, value
);
2387 if (NILP (no_error
))
2388 error ("Unknown or unsupported option");
2394 DEFUN ("serial-process-configure",
2395 Fserial_process_configure
,
2396 Sserial_process_configure
,
2398 doc
: /* Configure speed, bytesize, etc. of a serial process.
2400 Arguments are specified as keyword/argument pairs. Attributes that
2401 are not given are re-initialized from the process's current
2402 configuration (available via the function `process-contact') or set to
2403 reasonable default values. The following arguments are defined:
2409 -- Any of these arguments can be given to identify the process that is
2410 to be configured. If none of these arguments is given, the current
2411 buffer's process is used.
2413 :speed SPEED -- SPEED is the speed of the serial port in bits per
2414 second, also called baud rate. Any value can be given for SPEED, but
2415 most serial ports work only at a few defined values between 1200 and
2416 115200, with 9600 being the most common value. If SPEED is nil, the
2417 serial port is not configured any further, i.e., all other arguments
2418 are ignored. This may be useful for special serial ports such as
2419 Bluetooth-to-serial converters which can only be configured through AT
2420 commands. A value of nil for SPEED can be used only when passed
2421 through `make-serial-process' or `serial-term'.
2423 :bytesize BYTESIZE -- BYTESIZE is the number of bits per byte, which
2424 can be 7 or 8. If BYTESIZE is not given or nil, a value of 8 is used.
2426 :parity PARITY -- PARITY can be nil (don't use parity), the symbol
2427 `odd' (use odd parity), or the symbol `even' (use even parity). If
2428 PARITY is not given, no parity is used.
2430 :stopbits STOPBITS -- STOPBITS is the number of stopbits used to
2431 terminate a byte transmission. STOPBITS can be 1 or 2. If STOPBITS
2432 is not given or nil, 1 stopbit is used.
2434 :flowcontrol FLOWCONTROL -- FLOWCONTROL determines the type of
2435 flowcontrol to be used, which is either nil (don't use flowcontrol),
2436 the symbol `hw' (use RTS/CTS hardware flowcontrol), or the symbol `sw'
2437 \(use XON/XOFF software flowcontrol). If FLOWCONTROL is not given, no
2438 flowcontrol is used.
2440 `serial-process-configure' is called by `make-serial-process' for the
2441 initial configuration of the serial port.
2445 \(serial-process-configure :process "/dev/ttyS0" :speed 1200)
2447 \(serial-process-configure
2448 :buffer "COM1" :stopbits 1 :parity 'odd :flowcontrol 'hw)
2450 \(serial-process-configure :port "\\\\.\\COM13" :bytesize 7)
2452 usage: (serial-process-configure &rest ARGS) */)
2453 (ptrdiff_t nargs
, Lisp_Object
*args
)
2455 struct Lisp_Process
*p
;
2456 Lisp_Object contact
= Qnil
;
2457 Lisp_Object proc
= Qnil
;
2458 struct gcpro gcpro1
;
2460 contact
= Flist (nargs
, args
);
2463 proc
= Fplist_get (contact
, QCprocess
);
2465 proc
= Fplist_get (contact
, QCname
);
2467 proc
= Fplist_get (contact
, QCbuffer
);
2469 proc
= Fplist_get (contact
, QCport
);
2470 proc
= get_process (proc
);
2471 p
= XPROCESS (proc
);
2472 if (!EQ (p
->type
, Qserial
))
2473 error ("Not a serial process");
2475 if (NILP (Fplist_get (p
->childp
, QCspeed
)))
2481 serial_configure (p
, contact
);
2487 /* Used by make-serial-process to recover from errors. */
2489 make_serial_process_unwind (Lisp_Object proc
)
2491 if (!PROCESSP (proc
))
2493 remove_process (proc
);
2497 DEFUN ("make-serial-process", Fmake_serial_process
, Smake_serial_process
,
2499 doc
: /* Create and return a serial port process.
2501 In Emacs, serial port connections are represented by process objects,
2502 so input and output work as for subprocesses, and `delete-process'
2503 closes a serial port connection. However, a serial process has no
2504 process id, it cannot be signaled, and the status codes are different
2505 from normal processes.
2507 `make-serial-process' creates a process and a buffer, on which you
2508 probably want to use `process-send-string'. Try \\[serial-term] for
2509 an interactive terminal. See below for examples.
2511 Arguments are specified as keyword/argument pairs. The following
2512 arguments are defined:
2514 :port PORT -- (mandatory) PORT is the path or name of the serial port.
2515 For example, this could be "/dev/ttyS0" on Unix. On Windows, this
2516 could be "COM1", or "\\\\.\\COM10" for ports higher than COM9 (double
2517 the backslashes in strings).
2519 :speed SPEED -- (mandatory) is handled by `serial-process-configure',
2520 which is called by `make-serial-process'.
2522 :name NAME -- NAME is the name of the process. If NAME is not given,
2523 the value of PORT is used.
2525 :buffer BUFFER -- BUFFER is the buffer (or buffer-name) to associate
2526 with the process. Process output goes at the end of that buffer,
2527 unless you specify an output stream or filter function to handle the
2528 output. If BUFFER is not given, the value of NAME is used.
2530 :coding CODING -- If CODING is a symbol, it specifies the coding
2531 system used for both reading and writing for this process. If CODING
2532 is a cons (DECODING . ENCODING), DECODING is used for reading, and
2533 ENCODING is used for writing.
2535 :noquery BOOL -- When exiting Emacs, query the user if BOOL is nil and
2536 the process is running. If BOOL is not given, query before exiting.
2538 :stop BOOL -- Start process in the `stopped' state if BOOL is non-nil.
2539 In the stopped state, a serial process does not accept incoming data,
2540 but you can send outgoing data. The stopped state is cleared by
2541 `continue-process' and set by `stop-process'.
2543 :filter FILTER -- Install FILTER as the process filter.
2545 :sentinel SENTINEL -- Install SENTINEL as the process sentinel.
2547 :plist PLIST -- Install PLIST as the initial plist of the process.
2554 -- These arguments are handled by `serial-process-configure', which is
2555 called by `make-serial-process'.
2557 The original argument list, possibly modified by later configuration,
2558 is available via the function `process-contact'.
2562 \(make-serial-process :port "/dev/ttyS0" :speed 9600)
2564 \(make-serial-process :port "COM1" :speed 115200 :stopbits 2)
2566 \(make-serial-process :port "\\\\.\\COM13" :speed 1200 :bytesize 7 :parity 'odd)
2568 \(make-serial-process :port "/dev/tty.BlueConsole-SPP-1" :speed nil)
2570 usage: (make-serial-process &rest ARGS) */)
2571 (ptrdiff_t nargs
, Lisp_Object
*args
)
2574 Lisp_Object proc
, contact
, port
;
2575 struct Lisp_Process
*p
;
2576 struct gcpro gcpro1
;
2577 Lisp_Object name
, buffer
;
2578 Lisp_Object tem
, val
;
2579 ptrdiff_t specpdl_count
= -1;
2584 contact
= Flist (nargs
, args
);
2587 port
= Fplist_get (contact
, QCport
);
2589 error ("No port specified");
2590 CHECK_STRING (port
);
2592 if (NILP (Fplist_member (contact
, QCspeed
)))
2593 error (":speed not specified");
2594 if (!NILP (Fplist_get (contact
, QCspeed
)))
2595 CHECK_NUMBER (Fplist_get (contact
, QCspeed
));
2597 name
= Fplist_get (contact
, QCname
);
2600 CHECK_STRING (name
);
2601 proc
= make_process (name
);
2602 specpdl_count
= SPECPDL_INDEX ();
2603 record_unwind_protect (make_serial_process_unwind
, proc
);
2604 p
= XPROCESS (proc
);
2606 fd
= serial_open (SSDATA (port
));
2609 if (fd
> max_process_desc
)
2610 max_process_desc
= fd
;
2611 chan_process
[fd
] = proc
;
2613 buffer
= Fplist_get (contact
, QCbuffer
);
2616 buffer
= Fget_buffer_create (buffer
);
2619 p
->childp
= contact
;
2620 p
->plist
= Fcopy_sequence (Fplist_get (contact
, QCplist
));
2622 p
->sentinel
= Fplist_get (contact
, QCsentinel
);
2623 p
->filter
= Fplist_get (contact
, QCfilter
);
2625 if (tem
= Fplist_get (contact
, QCnoquery
), !NILP (tem
))
2626 p
->kill_without_query
= 1;
2627 if (tem
= Fplist_get (contact
, QCstop
), !NILP (tem
))
2631 if (!EQ (p
->command
, Qt
))
2633 FD_SET (fd
, &input_wait_mask
);
2634 FD_SET (fd
, &non_keyboard_wait_mask
);
2637 if (BUFFERP (buffer
))
2639 set_marker_both (p
->mark
, buffer
,
2640 BUF_ZV (XBUFFER (buffer
)),
2641 BUF_ZV_BYTE (XBUFFER (buffer
)));
2644 tem
= Fplist_member (contact
, QCcoding
);
2645 if (!NILP (tem
) && (!CONSP (tem
) || !CONSP (XCDR (tem
))))
2651 val
= XCAR (XCDR (tem
));
2655 else if (!NILP (Vcoding_system_for_read
))
2656 val
= Vcoding_system_for_read
;
2657 else if ((!NILP (buffer
) && NILP (BVAR (XBUFFER (buffer
), enable_multibyte_characters
)))
2658 || (NILP (buffer
) && NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
))))
2660 p
->decode_coding_system
= val
;
2665 val
= XCAR (XCDR (tem
));
2669 else if (!NILP (Vcoding_system_for_write
))
2670 val
= Vcoding_system_for_write
;
2671 else if ((!NILP (buffer
) && NILP (BVAR (XBUFFER (buffer
), enable_multibyte_characters
)))
2672 || (NILP (buffer
) && NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
))))
2674 p
->encode_coding_system
= val
;
2676 setup_process_coding_systems (proc
);
2677 p
->decoding_buf
= empty_unibyte_string
;
2678 p
->decoding_carryover
= 0;
2679 p
->encoding_buf
= empty_unibyte_string
;
2680 p
->inherit_coding_system_flag
2681 = !(!NILP (tem
) || NILP (buffer
) || !inherit_process_coding_system
);
2683 Fserial_process_configure (nargs
, args
);
2685 specpdl_ptr
= specpdl
+ specpdl_count
;
2691 /* Create a network stream/datagram client/server process. Treated
2692 exactly like a normal process when reading and writing. Primary
2693 differences are in status display and process deletion. A network
2694 connection has no PID; you cannot signal it. All you can do is
2695 stop/continue it and deactivate/close it via delete-process */
2697 DEFUN ("make-network-process", Fmake_network_process
, Smake_network_process
,
2699 doc
: /* Create and return a network server or client process.
2701 In Emacs, network connections are represented by process objects, so
2702 input and output work as for subprocesses and `delete-process' closes
2703 a network connection. However, a network process has no process id,
2704 it cannot be signaled, and the status codes are different from normal
2707 Arguments are specified as keyword/argument pairs. The following
2708 arguments are defined:
2710 :name NAME -- NAME is name for process. It is modified if necessary
2713 :buffer BUFFER -- BUFFER is the buffer (or buffer-name) to associate
2714 with the process. Process output goes at end of that buffer, unless
2715 you specify an output stream or filter function to handle the output.
2716 BUFFER may be also nil, meaning that this process is not associated
2719 :host HOST -- HOST is name of the host to connect to, or its IP
2720 address. The symbol `local' specifies the local host. If specified
2721 for a server process, it must be a valid name or address for the local
2722 host, and only clients connecting to that address will be accepted.
2724 :service SERVICE -- SERVICE is name of the service desired, or an
2725 integer specifying a port number to connect to. If SERVICE is t,
2726 a random port number is selected for the server. (If Emacs was
2727 compiled with getaddrinfo, a port number can also be specified as a
2728 string, e.g. "80", as well as an integer. This is not portable.)
2730 :type TYPE -- TYPE is the type of connection. The default (nil) is a
2731 stream type connection, `datagram' creates a datagram type connection,
2732 `seqpacket' creates a reliable datagram connection.
2734 :family FAMILY -- FAMILY is the address (and protocol) family for the
2735 service specified by HOST and SERVICE. The default (nil) is to use
2736 whatever address family (IPv4 or IPv6) that is defined for the host
2737 and port number specified by HOST and SERVICE. Other address families
2739 local -- for a local (i.e. UNIX) address specified by SERVICE.
2740 ipv4 -- use IPv4 address family only.
2741 ipv6 -- use IPv6 address family only.
2743 :local ADDRESS -- ADDRESS is the local address used for the connection.
2744 This parameter is ignored when opening a client process. When specified
2745 for a server process, the FAMILY, HOST and SERVICE args are ignored.
2747 :remote ADDRESS -- ADDRESS is the remote partner's address for the
2748 connection. This parameter is ignored when opening a stream server
2749 process. For a datagram server process, it specifies the initial
2750 setting of the remote datagram address. When specified for a client
2751 process, the FAMILY, HOST, and SERVICE args are ignored.
2753 The format of ADDRESS depends on the address family:
2754 - An IPv4 address is represented as an vector of integers [A B C D P]
2755 corresponding to numeric IP address A.B.C.D and port number P.
2756 - A local address is represented as a string with the address in the
2757 local address space.
2758 - An "unsupported family" address is represented by a cons (F . AV)
2759 where F is the family number and AV is a vector containing the socket
2760 address data with one element per address data byte. Do not rely on
2761 this format in portable code, as it may depend on implementation
2762 defined constants, data sizes, and data structure alignment.
2764 :coding CODING -- If CODING is a symbol, it specifies the coding
2765 system used for both reading and writing for this process. If CODING
2766 is a cons (DECODING . ENCODING), DECODING is used for reading, and
2767 ENCODING is used for writing.
2769 :nowait BOOL -- If BOOL is non-nil for a stream type client process,
2770 return without waiting for the connection to complete; instead, the
2771 sentinel function will be called with second arg matching "open" (if
2772 successful) or "failed" when the connect completes. Default is to use
2773 a blocking connect (i.e. wait) for stream type connections.
2775 :noquery BOOL -- Query the user unless BOOL is non-nil, and process is
2776 running when Emacs is exited.
2778 :stop BOOL -- Start process in the `stopped' state if BOOL non-nil.
2779 In the stopped state, a server process does not accept new
2780 connections, and a client process does not handle incoming traffic.
2781 The stopped state is cleared by `continue-process' and set by
2784 :filter FILTER -- Install FILTER as the process filter.
2786 :filter-multibyte BOOL -- If BOOL is non-nil, strings given to the
2787 process filter are multibyte, otherwise they are unibyte.
2788 If this keyword is not specified, the strings are multibyte if
2789 `default-enable-multibyte-characters' is non-nil.
2791 :sentinel SENTINEL -- Install SENTINEL as the process sentinel.
2793 :log LOG -- Install LOG as the server process log function. This
2794 function is called when the server accepts a network connection from a
2795 client. The arguments are SERVER, CLIENT, and MESSAGE, where SERVER
2796 is the server process, CLIENT is the new process for the connection,
2797 and MESSAGE is a string.
2799 :plist PLIST -- Install PLIST as the new process' initial plist.
2801 :server QLEN -- if QLEN is non-nil, create a server process for the
2802 specified FAMILY, SERVICE, and connection type (stream or datagram).
2803 If QLEN is an integer, it is used as the max. length of the server's
2804 pending connection queue (also known as the backlog); the default
2805 queue length is 5. Default is to create a client process.
2807 The following network options can be specified for this connection:
2809 :broadcast BOOL -- Allow send and receive of datagram broadcasts.
2810 :dontroute BOOL -- Only send to directly connected hosts.
2811 :keepalive BOOL -- Send keep-alive messages on network stream.
2812 :linger BOOL or TIMEOUT -- Send queued messages before closing.
2813 :oobinline BOOL -- Place out-of-band data in receive data stream.
2814 :priority INT -- Set protocol defined priority for sent packets.
2815 :reuseaddr BOOL -- Allow reusing a recently used local address
2816 (this is allowed by default for a server process).
2817 :bindtodevice NAME -- bind to interface NAME. Using this may require
2818 special privileges on some systems.
2820 Consult the relevant system programmer's manual pages for more
2821 information on using these options.
2824 A server process will listen for and accept connections from clients.
2825 When a client connection is accepted, a new network process is created
2826 for the connection with the following parameters:
2828 - The client's process name is constructed by concatenating the server
2829 process' NAME and a client identification string.
2830 - If the FILTER argument is non-nil, the client process will not get a
2831 separate process buffer; otherwise, the client's process buffer is a newly
2832 created buffer named after the server process' BUFFER name or process
2833 NAME concatenated with the client identification string.
2834 - The connection type and the process filter and sentinel parameters are
2835 inherited from the server process' TYPE, FILTER and SENTINEL.
2836 - The client process' contact info is set according to the client's
2837 addressing information (typically an IP address and a port number).
2838 - The client process' plist is initialized from the server's plist.
2840 Notice that the FILTER and SENTINEL args are never used directly by
2841 the server process. Also, the BUFFER argument is not used directly by
2842 the server process, but via the optional :log function, accepted (and
2843 failed) connections may be logged in the server process' buffer.
2845 The original argument list, modified with the actual connection
2846 information, is available via the `process-contact' function.
2848 usage: (make-network-process &rest ARGS) */)
2849 (ptrdiff_t nargs
, Lisp_Object
*args
)
2852 Lisp_Object contact
;
2853 struct Lisp_Process
*p
;
2854 #ifdef HAVE_GETADDRINFO
2855 struct addrinfo ai
, *res
, *lres
;
2856 struct addrinfo hints
;
2857 const char *portstring
;
2859 #else /* HAVE_GETADDRINFO */
2860 struct _emacs_addrinfo
2866 struct sockaddr
*ai_addr
;
2867 struct _emacs_addrinfo
*ai_next
;
2869 #endif /* HAVE_GETADDRINFO */
2870 struct sockaddr_in address_in
;
2871 #ifdef HAVE_LOCAL_SOCKETS
2872 struct sockaddr_un address_un
;
2877 int s
= -1, outch
, inch
;
2878 struct gcpro gcpro1
;
2879 ptrdiff_t count
= SPECPDL_INDEX ();
2881 Lisp_Object QCaddress
; /* one of QClocal or QCremote */
2883 Lisp_Object name
, buffer
, host
, service
, address
;
2884 Lisp_Object filter
, sentinel
;
2885 int is_non_blocking_client
= 0;
2886 int is_server
= 0, backlog
= 5;
2893 /* Save arguments for process-contact and clone-process. */
2894 contact
= Flist (nargs
, args
);
2898 /* Ensure socket support is loaded if available. */
2899 init_winsock (TRUE
);
2902 /* :type TYPE (nil: stream, datagram */
2903 tem
= Fplist_get (contact
, QCtype
);
2905 socktype
= SOCK_STREAM
;
2906 #ifdef DATAGRAM_SOCKETS
2907 else if (EQ (tem
, Qdatagram
))
2908 socktype
= SOCK_DGRAM
;
2910 #ifdef HAVE_SEQPACKET
2911 else if (EQ (tem
, Qseqpacket
))
2912 socktype
= SOCK_SEQPACKET
;
2915 error ("Unsupported connection type");
2918 tem
= Fplist_get (contact
, QCserver
);
2921 /* Don't support network sockets when non-blocking mode is
2922 not available, since a blocked Emacs is not useful. */
2923 #if !defined (O_NONBLOCK) && !defined (O_NDELAY)
2924 error ("Network servers not supported");
2927 if (TYPE_RANGED_INTEGERP (int, tem
))
2928 backlog
= XINT (tem
);
2932 /* Make QCaddress an alias for :local (server) or :remote (client). */
2933 QCaddress
= is_server
? QClocal
: QCremote
;
2936 if (!is_server
&& socktype
!= SOCK_DGRAM
2937 && (tem
= Fplist_get (contact
, QCnowait
), !NILP (tem
)))
2939 #ifndef NON_BLOCKING_CONNECT
2940 error ("Non-blocking connect not supported");
2942 is_non_blocking_client
= 1;
2946 name
= Fplist_get (contact
, QCname
);
2947 buffer
= Fplist_get (contact
, QCbuffer
);
2948 filter
= Fplist_get (contact
, QCfilter
);
2949 sentinel
= Fplist_get (contact
, QCsentinel
);
2951 CHECK_STRING (name
);
2953 /* Initialize addrinfo structure in case we don't use getaddrinfo. */
2954 ai
.ai_socktype
= socktype
;
2959 /* :local ADDRESS or :remote ADDRESS */
2960 address
= Fplist_get (contact
, QCaddress
);
2961 if (!NILP (address
))
2963 host
= service
= Qnil
;
2965 if (!(ai
.ai_addrlen
= get_lisp_to_sockaddr_size (address
, &family
)))
2966 error ("Malformed :address");
2967 ai
.ai_family
= family
;
2968 ai
.ai_addr
= alloca (ai
.ai_addrlen
);
2969 conv_lisp_to_sockaddr (family
, address
, ai
.ai_addr
, ai
.ai_addrlen
);
2973 /* :family FAMILY -- nil (for Inet), local, or integer. */
2974 tem
= Fplist_get (contact
, QCfamily
);
2977 #if defined (HAVE_GETADDRINFO) && defined (AF_INET6)
2983 #ifdef HAVE_LOCAL_SOCKETS
2984 else if (EQ (tem
, Qlocal
))
2988 else if (EQ (tem
, Qipv6
))
2991 else if (EQ (tem
, Qipv4
))
2993 else if (TYPE_RANGED_INTEGERP (int, tem
))
2994 family
= XINT (tem
);
2996 error ("Unknown address family");
2998 ai
.ai_family
= family
;
3000 /* :service SERVICE -- string, integer (port number), or t (random port). */
3001 service
= Fplist_get (contact
, QCservice
);
3003 /* :host HOST -- hostname, ip address, or 'local for localhost. */
3004 host
= Fplist_get (contact
, QChost
);
3007 if (EQ (host
, Qlocal
))
3008 /* Depending on setup, "localhost" may map to different IPv4 and/or
3009 IPv6 addresses, so it's better to be explicit. (Bug#6781) */
3010 host
= build_string ("127.0.0.1");
3011 CHECK_STRING (host
);
3014 #ifdef HAVE_LOCAL_SOCKETS
3015 if (family
== AF_LOCAL
)
3019 message (":family local ignores the :host \"%s\" property",
3021 contact
= Fplist_put (contact
, QChost
, Qnil
);
3024 CHECK_STRING (service
);
3025 memset (&address_un
, 0, sizeof address_un
);
3026 address_un
.sun_family
= AF_LOCAL
;
3027 strncpy (address_un
.sun_path
, SSDATA (service
), sizeof address_un
.sun_path
);
3028 ai
.ai_addr
= (struct sockaddr
*) &address_un
;
3029 ai
.ai_addrlen
= sizeof address_un
;
3034 /* Slow down polling to every ten seconds.
3035 Some kernels have a bug which causes retrying connect to fail
3036 after a connect. Polling can interfere with gethostbyname too. */
3037 #ifdef POLL_FOR_INPUT
3038 if (socktype
!= SOCK_DGRAM
)
3040 record_unwind_protect (unwind_stop_other_atimers
, Qnil
);
3041 bind_polling_period (10);
3045 #ifdef HAVE_GETADDRINFO
3046 /* If we have a host, use getaddrinfo to resolve both host and service.
3047 Otherwise, use getservbyname to lookup the service. */
3051 /* SERVICE can either be a string or int.
3052 Convert to a C string for later use by getaddrinfo. */
3053 if (EQ (service
, Qt
))
3055 else if (INTEGERP (service
))
3057 sprintf (portbuf
, "%"pI
"d", XINT (service
));
3058 portstring
= portbuf
;
3062 CHECK_STRING (service
);
3063 portstring
= SSDATA (service
);
3068 memset (&hints
, 0, sizeof (hints
));
3070 hints
.ai_family
= family
;
3071 hints
.ai_socktype
= socktype
;
3072 hints
.ai_protocol
= 0;
3074 #ifdef HAVE_RES_INIT
3078 ret
= getaddrinfo (SSDATA (host
), portstring
, &hints
, &res
);
3080 #ifdef HAVE_GAI_STRERROR
3081 error ("%s/%s %s", SSDATA (host
), portstring
, gai_strerror (ret
));
3083 error ("%s/%s getaddrinfo error %d", SSDATA (host
), portstring
, ret
);
3089 #endif /* HAVE_GETADDRINFO */
3091 /* We end up here if getaddrinfo is not defined, or in case no hostname
3092 has been specified (e.g. for a local server process). */
3094 if (EQ (service
, Qt
))
3096 else if (INTEGERP (service
))
3097 port
= htons ((unsigned short) XINT (service
));
3100 struct servent
*svc_info
;
3101 CHECK_STRING (service
);
3102 svc_info
= getservbyname (SSDATA (service
),
3103 (socktype
== SOCK_DGRAM
? "udp" : "tcp"));
3105 error ("Unknown service: %s", SDATA (service
));
3106 port
= svc_info
->s_port
;
3109 memset (&address_in
, 0, sizeof address_in
);
3110 address_in
.sin_family
= family
;
3111 address_in
.sin_addr
.s_addr
= INADDR_ANY
;
3112 address_in
.sin_port
= port
;
3114 #ifndef HAVE_GETADDRINFO
3117 struct hostent
*host_info_ptr
;
3119 /* gethostbyname may fail with TRY_AGAIN, but we don't honor that,
3120 as it may `hang' Emacs for a very long time. */
3124 #ifdef HAVE_RES_INIT
3128 host_info_ptr
= gethostbyname (SDATA (host
));
3133 memcpy (&address_in
.sin_addr
, host_info_ptr
->h_addr
,
3134 host_info_ptr
->h_length
);
3135 family
= host_info_ptr
->h_addrtype
;
3136 address_in
.sin_family
= family
;
3139 /* Attempt to interpret host as numeric inet address */
3141 unsigned long numeric_addr
;
3142 numeric_addr
= inet_addr (SSDATA (host
));
3143 if (numeric_addr
== -1)
3144 error ("Unknown host \"%s\"", SDATA (host
));
3146 memcpy (&address_in
.sin_addr
, &numeric_addr
,
3147 sizeof (address_in
.sin_addr
));
3151 #endif /* not HAVE_GETADDRINFO */
3153 ai
.ai_family
= family
;
3154 ai
.ai_addr
= (struct sockaddr
*) &address_in
;
3155 ai
.ai_addrlen
= sizeof address_in
;
3159 /* Do this in case we never enter the for-loop below. */
3160 count1
= SPECPDL_INDEX ();
3163 for (lres
= res
; lres
; lres
= lres
->ai_next
)
3172 s
= socket (lres
->ai_family
, lres
->ai_socktype
, lres
->ai_protocol
);
3179 #ifdef DATAGRAM_SOCKETS
3180 if (!is_server
&& socktype
== SOCK_DGRAM
)
3182 #endif /* DATAGRAM_SOCKETS */
3184 #ifdef NON_BLOCKING_CONNECT
3185 if (is_non_blocking_client
)
3188 ret
= fcntl (s
, F_SETFL
, O_NONBLOCK
);
3190 ret
= fcntl (s
, F_SETFL
, O_NDELAY
);
3202 /* Make us close S if quit. */
3203 record_unwind_protect (close_file_unwind
, make_number (s
));
3205 /* Parse network options in the arg list.
3206 We simply ignore anything which isn't a known option (including other keywords).
3207 An error is signaled if setting a known option fails. */
3208 for (optn
= optbits
= 0; optn
< nargs
-1; optn
+= 2)
3209 optbits
|= set_socket_option (s
, args
[optn
], args
[optn
+1]);
3213 /* Configure as a server socket. */
3215 /* SO_REUSEADDR = 1 is default for server sockets; must specify
3216 explicit :reuseaddr key to override this. */
3217 #ifdef HAVE_LOCAL_SOCKETS
3218 if (family
!= AF_LOCAL
)
3220 if (!(optbits
& (1 << OPIX_REUSEADDR
)))
3223 if (setsockopt (s
, SOL_SOCKET
, SO_REUSEADDR
, &optval
, sizeof optval
))
3224 report_file_error ("Cannot set reuse option on server socket", Qnil
);
3227 if (bind (s
, lres
->ai_addr
, lres
->ai_addrlen
))
3228 report_file_error ("Cannot bind server socket", Qnil
);
3230 #ifdef HAVE_GETSOCKNAME
3231 if (EQ (service
, Qt
))
3233 struct sockaddr_in sa1
;
3234 socklen_t len1
= sizeof (sa1
);
3235 if (getsockname (s
, (struct sockaddr
*)&sa1
, &len1
) == 0)
3237 ((struct sockaddr_in
*)(lres
->ai_addr
))->sin_port
= sa1
.sin_port
;
3238 service
= make_number (ntohs (sa1
.sin_port
));
3239 contact
= Fplist_put (contact
, QCservice
, service
);
3244 if (socktype
!= SOCK_DGRAM
&& listen (s
, backlog
))
3245 report_file_error ("Cannot listen on server socket", Qnil
);
3253 ret
= connect (s
, lres
->ai_addr
, lres
->ai_addrlen
);
3256 if (ret
== 0 || xerrno
== EISCONN
)
3258 /* The unwind-protect will be discarded afterwards.
3259 Likewise for immediate_quit. */
3263 #ifdef NON_BLOCKING_CONNECT
3265 if (is_non_blocking_client
&& xerrno
== EINPROGRESS
)
3269 if (is_non_blocking_client
&& xerrno
== EWOULDBLOCK
)
3276 if (xerrno
== EINTR
)
3278 /* Unlike most other syscalls connect() cannot be called
3279 again. (That would return EALREADY.) The proper way to
3280 wait for completion is select(). */
3288 sc
= select (s
+ 1, (SELECT_TYPE
*)0, &fdset
, (SELECT_TYPE
*)0,
3295 report_file_error ("select failed", Qnil
);
3299 len
= sizeof xerrno
;
3300 eassert (FD_ISSET (s
, &fdset
));
3301 if (getsockopt (s
, SOL_SOCKET
, SO_ERROR
, &xerrno
, &len
) == -1)
3302 report_file_error ("getsockopt failed", Qnil
);
3304 errno
= xerrno
, report_file_error ("error during connect", Qnil
);
3308 #endif /* !WINDOWSNT */
3312 /* Discard the unwind protect closing S. */
3313 specpdl_ptr
= specpdl
+ count1
;
3318 if (xerrno
== EINTR
)
3325 #ifdef DATAGRAM_SOCKETS
3326 if (socktype
== SOCK_DGRAM
)
3328 if (datagram_address
[s
].sa
)
3330 datagram_address
[s
].sa
= (struct sockaddr
*) xmalloc (lres
->ai_addrlen
);
3331 datagram_address
[s
].len
= lres
->ai_addrlen
;
3335 memset (datagram_address
[s
].sa
, 0, lres
->ai_addrlen
);
3336 if (remote
= Fplist_get (contact
, QCremote
), !NILP (remote
))
3339 rlen
= get_lisp_to_sockaddr_size (remote
, &rfamily
);
3340 if (rfamily
== lres
->ai_family
&& rlen
== lres
->ai_addrlen
)
3341 conv_lisp_to_sockaddr (rfamily
, remote
,
3342 datagram_address
[s
].sa
, rlen
);
3346 memcpy (datagram_address
[s
].sa
, lres
->ai_addr
, lres
->ai_addrlen
);
3349 contact
= Fplist_put (contact
, QCaddress
,
3350 conv_sockaddr_to_lisp (lres
->ai_addr
, lres
->ai_addrlen
));
3351 #ifdef HAVE_GETSOCKNAME
3354 struct sockaddr_in sa1
;
3355 socklen_t len1
= sizeof (sa1
);
3356 if (getsockname (s
, (struct sockaddr
*)&sa1
, &len1
) == 0)
3357 contact
= Fplist_put (contact
, QClocal
,
3358 conv_sockaddr_to_lisp ((struct sockaddr
*)&sa1
, len1
));
3365 #ifdef HAVE_GETADDRINFO
3374 /* Discard the unwind protect for closing S, if any. */
3375 specpdl_ptr
= specpdl
+ count1
;
3377 /* Unwind bind_polling_period and request_sigio. */
3378 unbind_to (count
, Qnil
);
3382 /* If non-blocking got this far - and failed - assume non-blocking is
3383 not supported after all. This is probably a wrong assumption, but
3384 the normal blocking calls to open-network-stream handles this error
3386 if (is_non_blocking_client
)
3391 report_file_error ("make server process failed", contact
);
3393 report_file_error ("make client process failed", contact
);
3400 buffer
= Fget_buffer_create (buffer
);
3401 proc
= make_process (name
);
3403 chan_process
[inch
] = proc
;
3406 fcntl (inch
, F_SETFL
, O_NONBLOCK
);
3409 fcntl (inch
, F_SETFL
, O_NDELAY
);
3413 p
= XPROCESS (proc
);
3415 p
->childp
= contact
;
3416 p
->plist
= Fcopy_sequence (Fplist_get (contact
, QCplist
));
3420 p
->sentinel
= sentinel
;
3422 p
->log
= Fplist_get (contact
, QClog
);
3423 if (tem
= Fplist_get (contact
, QCnoquery
), !NILP (tem
))
3424 p
->kill_without_query
= 1;
3425 if ((tem
= Fplist_get (contact
, QCstop
), !NILP (tem
)))
3430 if (is_server
&& socktype
!= SOCK_DGRAM
)
3431 p
->status
= Qlisten
;
3433 /* Make the process marker point into the process buffer (if any). */
3434 if (BUFFERP (buffer
))
3435 set_marker_both (p
->mark
, buffer
,
3436 BUF_ZV (XBUFFER (buffer
)),
3437 BUF_ZV_BYTE (XBUFFER (buffer
)));
3439 #ifdef NON_BLOCKING_CONNECT
3440 if (is_non_blocking_client
)
3442 /* We may get here if connect did succeed immediately. However,
3443 in that case, we still need to signal this like a non-blocking
3445 p
->status
= Qconnect
;
3446 if (!FD_ISSET (inch
, &connect_wait_mask
))
3448 FD_SET (inch
, &connect_wait_mask
);
3449 FD_SET (inch
, &write_mask
);
3450 num_pending_connects
++;
3455 /* A server may have a client filter setting of Qt, but it must
3456 still listen for incoming connects unless it is stopped. */
3457 if ((!EQ (p
->filter
, Qt
) && !EQ (p
->command
, Qt
))
3458 || (EQ (p
->status
, Qlisten
) && NILP (p
->command
)))
3460 FD_SET (inch
, &input_wait_mask
);
3461 FD_SET (inch
, &non_keyboard_wait_mask
);
3464 if (inch
> max_process_desc
)
3465 max_process_desc
= inch
;
3467 tem
= Fplist_member (contact
, QCcoding
);
3468 if (!NILP (tem
) && (!CONSP (tem
) || !CONSP (XCDR (tem
))))
3469 tem
= Qnil
; /* No error message (too late!). */
3472 /* Setup coding systems for communicating with the network stream. */
3473 struct gcpro inner_gcpro1
;
3474 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
3475 Lisp_Object coding_systems
= Qt
;
3476 Lisp_Object fargs
[5], val
;
3480 val
= XCAR (XCDR (tem
));
3484 else if (!NILP (Vcoding_system_for_read
))
3485 val
= Vcoding_system_for_read
;
3486 else if ((!NILP (buffer
) && NILP (BVAR (XBUFFER (buffer
), enable_multibyte_characters
)))
3487 || (NILP (buffer
) && NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
))))
3488 /* We dare not decode end-of-line format by setting VAL to
3489 Qraw_text, because the existing Emacs Lisp libraries
3490 assume that they receive bare code including a sequene of
3495 if (NILP (host
) || NILP (service
))
3496 coding_systems
= Qnil
;
3499 fargs
[0] = Qopen_network_stream
, fargs
[1] = name
,
3500 fargs
[2] = buffer
, fargs
[3] = host
, fargs
[4] = service
;
3501 GCPRO1_VAR (proc
, inner_gcpro
);
3502 coding_systems
= Ffind_operation_coding_system (5, fargs
);
3503 UNGCPRO_VAR (inner_gcpro
);
3505 if (CONSP (coding_systems
))
3506 val
= XCAR (coding_systems
);
3507 else if (CONSP (Vdefault_process_coding_system
))
3508 val
= XCAR (Vdefault_process_coding_system
);
3512 p
->decode_coding_system
= val
;
3516 val
= XCAR (XCDR (tem
));
3520 else if (!NILP (Vcoding_system_for_write
))
3521 val
= Vcoding_system_for_write
;
3522 else if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3526 if (EQ (coding_systems
, Qt
))
3528 if (NILP (host
) || NILP (service
))
3529 coding_systems
= Qnil
;
3532 fargs
[0] = Qopen_network_stream
, fargs
[1] = name
,
3533 fargs
[2] = buffer
, fargs
[3] = host
, fargs
[4] = service
;
3534 GCPRO1_VAR (proc
, inner_gcpro
);
3535 coding_systems
= Ffind_operation_coding_system (5, fargs
);
3536 UNGCPRO_VAR (inner_gcpro
);
3539 if (CONSP (coding_systems
))
3540 val
= XCDR (coding_systems
);
3541 else if (CONSP (Vdefault_process_coding_system
))
3542 val
= XCDR (Vdefault_process_coding_system
);
3546 p
->encode_coding_system
= val
;
3548 setup_process_coding_systems (proc
);
3550 p
->decoding_buf
= empty_unibyte_string
;
3551 p
->decoding_carryover
= 0;
3552 p
->encoding_buf
= empty_unibyte_string
;
3554 p
->inherit_coding_system_flag
3555 = !(!NILP (tem
) || NILP (buffer
) || !inherit_process_coding_system
);
3562 #if defined (HAVE_NET_IF_H)
3565 DEFUN ("network-interface-list", Fnetwork_interface_list
, Snetwork_interface_list
, 0, 0, 0,
3566 doc
: /* Return an alist of all network interfaces and their network address.
3567 Each element is a cons, the car of which is a string containing the
3568 interface name, and the cdr is the network address in internal
3569 format; see the description of ADDRESS in `make-network-process'. */)
3572 struct ifconf ifconf
;
3573 struct ifreq
*ifreq
;
3575 ptrdiff_t buf_size
= 512;
3579 s
= socket (AF_INET
, SOCK_STREAM
, 0);
3585 buf
= xpalloc (buf
, &buf_size
, 1, INT_MAX
, 1);
3586 ifconf
.ifc_buf
= buf
;
3587 ifconf
.ifc_len
= buf_size
;
3588 if (ioctl (s
, SIOCGIFCONF
, &ifconf
))
3595 while (ifconf
.ifc_len
== buf_size
);
3600 ifreq
= ifconf
.ifc_req
;
3601 while ((char *) ifreq
< (char *) ifconf
.ifc_req
+ ifconf
.ifc_len
)
3603 struct ifreq
*ifq
= ifreq
;
3604 #ifdef HAVE_STRUCT_IFREQ_IFR_ADDR_SA_LEN
3605 #define SIZEOF_IFREQ(sif) \
3606 ((sif)->ifr_addr.sa_len < sizeof (struct sockaddr) \
3607 ? sizeof (*(sif)) : sizeof ((sif)->ifr_name) + (sif)->ifr_addr.sa_len)
3609 int len
= SIZEOF_IFREQ (ifq
);
3611 int len
= sizeof (*ifreq
);
3613 char namebuf
[sizeof (ifq
->ifr_name
) + 1];
3615 ifreq
= (struct ifreq
*) ((char *) ifreq
+ len
);
3617 if (ifq
->ifr_addr
.sa_family
!= AF_INET
)
3620 memcpy (namebuf
, ifq
->ifr_name
, sizeof (ifq
->ifr_name
));
3621 namebuf
[sizeof (ifq
->ifr_name
)] = 0;
3622 res
= Fcons (Fcons (build_string (namebuf
),
3623 conv_sockaddr_to_lisp (&ifq
->ifr_addr
,
3624 sizeof (struct sockaddr
))),
3631 #endif /* SIOCGIFCONF */
3633 #if defined (SIOCGIFADDR) || defined (SIOCGIFHWADDR) || defined (SIOCGIFFLAGS)
3637 const char *flag_sym
;
3640 static const struct ifflag_def ifflag_table
[] = {
3644 #ifdef IFF_BROADCAST
3645 { IFF_BROADCAST
, "broadcast" },
3648 { IFF_DEBUG
, "debug" },
3651 { IFF_LOOPBACK
, "loopback" },
3653 #ifdef IFF_POINTOPOINT
3654 { IFF_POINTOPOINT
, "pointopoint" },
3657 { IFF_RUNNING
, "running" },
3660 { IFF_NOARP
, "noarp" },
3663 { IFF_PROMISC
, "promisc" },
3665 #ifdef IFF_NOTRAILERS
3666 #ifdef NS_IMPL_COCOA
3667 /* Really means smart, notrailers is obsolete */
3668 { IFF_NOTRAILERS
, "smart" },
3670 { IFF_NOTRAILERS
, "notrailers" },
3674 { IFF_ALLMULTI
, "allmulti" },
3677 { IFF_MASTER
, "master" },
3680 { IFF_SLAVE
, "slave" },
3682 #ifdef IFF_MULTICAST
3683 { IFF_MULTICAST
, "multicast" },
3686 { IFF_PORTSEL
, "portsel" },
3688 #ifdef IFF_AUTOMEDIA
3689 { IFF_AUTOMEDIA
, "automedia" },
3692 { IFF_DYNAMIC
, "dynamic" },
3695 { IFF_OACTIVE
, "oactive" }, /* OpenBSD: transmission in progress */
3698 { IFF_SIMPLEX
, "simplex" }, /* OpenBSD: can't hear own transmissions */
3701 { IFF_LINK0
, "link0" }, /* OpenBSD: per link layer defined bit */
3704 { IFF_LINK1
, "link1" }, /* OpenBSD: per link layer defined bit */
3707 { IFF_LINK2
, "link2" }, /* OpenBSD: per link layer defined bit */
3712 DEFUN ("network-interface-info", Fnetwork_interface_info
, Snetwork_interface_info
, 1, 1, 0,
3713 doc
: /* Return information about network interface named IFNAME.
3714 The return value is a list (ADDR BCAST NETMASK HWADDR FLAGS),
3715 where ADDR is the layer 3 address, BCAST is the layer 3 broadcast address,
3716 NETMASK is the layer 3 network mask, HWADDR is the layer 2 addres, and
3717 FLAGS is the current flags of the interface. */)
3718 (Lisp_Object ifname
)
3721 Lisp_Object res
= Qnil
;
3725 #if (! (defined SIOCGIFHWADDR && defined HAVE_STRUCT_IFREQ_IFR_HWADDR) \
3726 && defined HAVE_GETIFADDRS && defined LLADDR)
3727 struct ifaddrs
*ifap
;
3730 CHECK_STRING (ifname
);
3732 memset (rq
.ifr_name
, 0, sizeof rq
.ifr_name
);
3733 strncpy (rq
.ifr_name
, SSDATA (ifname
), sizeof (rq
.ifr_name
));
3735 s
= socket (AF_INET
, SOCK_STREAM
, 0);
3740 #if defined (SIOCGIFFLAGS) && defined (HAVE_STRUCT_IFREQ_IFR_FLAGS)
3741 if (ioctl (s
, SIOCGIFFLAGS
, &rq
) == 0)
3743 int flags
= rq
.ifr_flags
;
3744 const struct ifflag_def
*fp
;
3747 /* If flags is smaller than int (i.e. short) it may have the high bit set
3748 due to IFF_MULTICAST. In that case, sign extending it into
3750 if (flags
< 0 && sizeof (rq
.ifr_flags
) < sizeof (flags
))
3751 flags
= (unsigned short) rq
.ifr_flags
;
3754 for (fp
= ifflag_table
; flags
!= 0 && fp
->flag_sym
; fp
++)
3756 if (flags
& fp
->flag_bit
)
3758 elt
= Fcons (intern (fp
->flag_sym
), elt
);
3759 flags
-= fp
->flag_bit
;
3762 for (fnum
= 0; flags
&& fnum
< 32; flags
>>= 1, fnum
++)
3766 elt
= Fcons (make_number (fnum
), elt
);
3771 res
= Fcons (elt
, res
);
3774 #if defined (SIOCGIFHWADDR) && defined (HAVE_STRUCT_IFREQ_IFR_HWADDR)
3775 if (ioctl (s
, SIOCGIFHWADDR
, &rq
) == 0)
3777 Lisp_Object hwaddr
= Fmake_vector (make_number (6), Qnil
);
3778 register struct Lisp_Vector
*p
= XVECTOR (hwaddr
);
3782 for (n
= 0; n
< 6; n
++)
3783 p
->contents
[n
] = make_number (((unsigned char *)&rq
.ifr_hwaddr
.sa_data
[0])[n
]);
3784 elt
= Fcons (make_number (rq
.ifr_hwaddr
.sa_family
), hwaddr
);
3786 #elif defined (HAVE_GETIFADDRS) && defined (LLADDR)
3787 if (getifaddrs (&ifap
) != -1)
3789 Lisp_Object hwaddr
= Fmake_vector (make_number (6), Qnil
);
3790 register struct Lisp_Vector
*p
= XVECTOR (hwaddr
);
3793 for (it
= ifap
; it
!= NULL
; it
= it
->ifa_next
)
3795 struct sockaddr_dl
*sdl
= (struct sockaddr_dl
*) it
->ifa_addr
;
3796 unsigned char linkaddr
[6];
3799 if (it
->ifa_addr
->sa_family
!= AF_LINK
3800 || strcmp (it
->ifa_name
, SSDATA (ifname
)) != 0
3801 || sdl
->sdl_alen
!= 6)
3804 memcpy (linkaddr
, LLADDR (sdl
), sdl
->sdl_alen
);
3805 for (n
= 0; n
< 6; n
++)
3806 p
->contents
[n
] = make_number (linkaddr
[n
]);
3808 elt
= Fcons (make_number (it
->ifa_addr
->sa_family
), hwaddr
);
3812 #ifdef HAVE_FREEIFADDRS
3816 #endif /* HAVE_GETIFADDRS && LLADDR */
3818 res
= Fcons (elt
, res
);
3821 #if defined (SIOCGIFNETMASK) && (defined (HAVE_STRUCT_IFREQ_IFR_NETMASK) || defined (HAVE_STRUCT_IFREQ_IFR_ADDR))
3822 if (ioctl (s
, SIOCGIFNETMASK
, &rq
) == 0)
3825 #ifdef HAVE_STRUCT_IFREQ_IFR_NETMASK
3826 elt
= conv_sockaddr_to_lisp (&rq
.ifr_netmask
, sizeof (rq
.ifr_netmask
));
3828 elt
= conv_sockaddr_to_lisp (&rq
.ifr_addr
, sizeof (rq
.ifr_addr
));
3832 res
= Fcons (elt
, res
);
3835 #if defined (SIOCGIFBRDADDR) && defined (HAVE_STRUCT_IFREQ_IFR_BROADADDR)
3836 if (ioctl (s
, SIOCGIFBRDADDR
, &rq
) == 0)
3839 elt
= conv_sockaddr_to_lisp (&rq
.ifr_broadaddr
, sizeof (rq
.ifr_broadaddr
));
3842 res
= Fcons (elt
, res
);
3845 #if defined (SIOCGIFADDR) && defined (HAVE_STRUCT_IFREQ_IFR_ADDR)
3846 if (ioctl (s
, SIOCGIFADDR
, &rq
) == 0)
3849 elt
= conv_sockaddr_to_lisp (&rq
.ifr_addr
, sizeof (rq
.ifr_addr
));
3852 res
= Fcons (elt
, res
);
3856 return any
? res
: Qnil
;
3859 #endif /* defined (HAVE_NET_IF_H) */
3861 /* Turn off input and output for process PROC. */
3864 deactivate_process (Lisp_Object proc
)
3866 register int inchannel
, outchannel
;
3867 register struct Lisp_Process
*p
= XPROCESS (proc
);
3870 /* Delete GnuTLS structures in PROC, if any. */
3871 emacs_gnutls_deinit (proc
);
3872 #endif /* HAVE_GNUTLS */
3874 inchannel
= p
->infd
;
3875 outchannel
= p
->outfd
;
3877 #ifdef ADAPTIVE_READ_BUFFERING
3878 if (p
->read_output_delay
> 0)
3880 if (--process_output_delay_count
< 0)
3881 process_output_delay_count
= 0;
3882 p
->read_output_delay
= 0;
3883 p
->read_output_skip
= 0;
3889 /* Beware SIGCHLD hereabouts. */
3890 flush_pending_output (inchannel
);
3891 emacs_close (inchannel
);
3892 if (outchannel
>= 0 && outchannel
!= inchannel
)
3893 emacs_close (outchannel
);
3897 #ifdef DATAGRAM_SOCKETS
3898 if (DATAGRAM_CHAN_P (inchannel
))
3900 xfree (datagram_address
[inchannel
].sa
);
3901 datagram_address
[inchannel
].sa
= 0;
3902 datagram_address
[inchannel
].len
= 0;
3905 chan_process
[inchannel
] = Qnil
;
3906 FD_CLR (inchannel
, &input_wait_mask
);
3907 FD_CLR (inchannel
, &non_keyboard_wait_mask
);
3908 #ifdef NON_BLOCKING_CONNECT
3909 if (FD_ISSET (inchannel
, &connect_wait_mask
))
3911 FD_CLR (inchannel
, &connect_wait_mask
);
3912 FD_CLR (inchannel
, &write_mask
);
3913 if (--num_pending_connects
< 0)
3917 if (inchannel
== max_process_desc
)
3920 /* We just closed the highest-numbered process input descriptor,
3921 so recompute the highest-numbered one now. */
3922 max_process_desc
= 0;
3923 for (i
= 0; i
< MAXDESC
; i
++)
3924 if (!NILP (chan_process
[i
]))
3925 max_process_desc
= i
;
3931 DEFUN ("accept-process-output", Faccept_process_output
, Saccept_process_output
,
3933 doc
: /* Allow any pending output from subprocesses to be read by Emacs.
3934 It is read into the process' buffers or given to their filter functions.
3935 Non-nil arg PROCESS means do not return until some output has been received
3938 Non-nil second arg SECONDS and third arg MILLISEC are number of seconds
3939 and milliseconds to wait; return after that much time whether or not
3940 there is any subprocess output. If SECONDS is a floating point number,
3941 it specifies a fractional number of seconds to wait.
3942 The MILLISEC argument is obsolete and should be avoided.
3944 If optional fourth arg JUST-THIS-ONE is non-nil, only accept output
3945 from PROCESS, suspending reading output from other processes.
3946 If JUST-THIS-ONE is an integer, don't run any timers either.
3947 Return non-nil if we received any output before the timeout expired. */)
3948 (register Lisp_Object process
, Lisp_Object seconds
, Lisp_Object millisec
, Lisp_Object just_this_one
)
3950 int secs
= -1, usecs
= 0;
3952 if (! NILP (process
))
3953 CHECK_PROCESS (process
);
3955 just_this_one
= Qnil
;
3957 if (!NILP (millisec
))
3958 { /* Obsolete calling convention using integers rather than floats. */
3959 CHECK_NUMBER (millisec
);
3961 seconds
= make_float (XINT (millisec
) / 1000.0);
3964 CHECK_NUMBER (seconds
);
3965 seconds
= make_float (XINT (millisec
) / 1000.0 + XINT (seconds
));
3969 if (!NILP (seconds
))
3971 double duration
= extract_float (seconds
);
3973 duration_to_sec_usec (duration
, &secs
, &usecs
);
3975 else if (!NILP (process
))
3979 (wait_reading_process_output (secs
, usecs
, 0, 0,
3981 !NILP (process
) ? XPROCESS (process
) : NULL
,
3982 NILP (just_this_one
) ? 0 :
3983 !INTEGERP (just_this_one
) ? 1 : -1)
3987 /* Accept a connection for server process SERVER on CHANNEL. */
3989 static int connect_counter
= 0;
3992 server_accept_connection (Lisp_Object server
, int channel
)
3994 Lisp_Object proc
, caller
, name
, buffer
;
3995 Lisp_Object contact
, host
, service
;
3996 struct Lisp_Process
*ps
= XPROCESS (server
);
3997 struct Lisp_Process
*p
;
4001 struct sockaddr_in in
;
4003 struct sockaddr_in6 in6
;
4005 #ifdef HAVE_LOCAL_SOCKETS
4006 struct sockaddr_un un
;
4009 socklen_t len
= sizeof saddr
;
4011 s
= accept (channel
, &saddr
.sa
, &len
);
4020 if (code
== EWOULDBLOCK
)
4024 if (!NILP (ps
->log
))
4025 call3 (ps
->log
, server
, Qnil
,
4026 concat3 (build_string ("accept failed with code"),
4027 Fnumber_to_string (make_number (code
)),
4028 build_string ("\n")));
4034 /* Setup a new process to handle the connection. */
4036 /* Generate a unique identification of the caller, and build contact
4037 information for this process. */
4040 switch (saddr
.sa
.sa_family
)
4044 Lisp_Object args
[5];
4045 unsigned char *ip
= (unsigned char *)&saddr
.in
.sin_addr
.s_addr
;
4046 args
[0] = build_string ("%d.%d.%d.%d");
4047 args
[1] = make_number (*ip
++);
4048 args
[2] = make_number (*ip
++);
4049 args
[3] = make_number (*ip
++);
4050 args
[4] = make_number (*ip
++);
4051 host
= Fformat (5, args
);
4052 service
= make_number (ntohs (saddr
.in
.sin_port
));
4054 args
[0] = build_string (" <%s:%d>");
4057 caller
= Fformat (3, args
);
4064 Lisp_Object args
[9];
4065 uint16_t *ip6
= (uint16_t *)&saddr
.in6
.sin6_addr
;
4067 args
[0] = build_string ("%x:%x:%x:%x:%x:%x:%x:%x");
4068 for (i
= 0; i
< 8; i
++)
4069 args
[i
+1] = make_number (ntohs (ip6
[i
]));
4070 host
= Fformat (9, args
);
4071 service
= make_number (ntohs (saddr
.in
.sin_port
));
4073 args
[0] = build_string (" <[%s]:%d>");
4076 caller
= Fformat (3, args
);
4081 #ifdef HAVE_LOCAL_SOCKETS
4085 caller
= Fnumber_to_string (make_number (connect_counter
));
4086 caller
= concat3 (build_string (" <"), caller
, build_string (">"));
4090 /* Create a new buffer name for this process if it doesn't have a
4091 filter. The new buffer name is based on the buffer name or
4092 process name of the server process concatenated with the caller
4095 if (!NILP (ps
->filter
) && !EQ (ps
->filter
, Qt
))
4099 buffer
= ps
->buffer
;
4101 buffer
= Fbuffer_name (buffer
);
4106 buffer
= concat2 (buffer
, caller
);
4107 buffer
= Fget_buffer_create (buffer
);
4111 /* Generate a unique name for the new server process. Combine the
4112 server process name with the caller identification. */
4114 name
= concat2 (ps
->name
, caller
);
4115 proc
= make_process (name
);
4117 chan_process
[s
] = proc
;
4120 fcntl (s
, F_SETFL
, O_NONBLOCK
);
4123 fcntl (s
, F_SETFL
, O_NDELAY
);
4127 p
= XPROCESS (proc
);
4129 /* Build new contact information for this setup. */
4130 contact
= Fcopy_sequence (ps
->childp
);
4131 contact
= Fplist_put (contact
, QCserver
, Qnil
);
4132 contact
= Fplist_put (contact
, QChost
, host
);
4133 if (!NILP (service
))
4134 contact
= Fplist_put (contact
, QCservice
, service
);
4135 contact
= Fplist_put (contact
, QCremote
,
4136 conv_sockaddr_to_lisp (&saddr
.sa
, len
));
4137 #ifdef HAVE_GETSOCKNAME
4139 if (getsockname (s
, &saddr
.sa
, &len
) == 0)
4140 contact
= Fplist_put (contact
, QClocal
,
4141 conv_sockaddr_to_lisp (&saddr
.sa
, len
));
4144 p
->childp
= contact
;
4145 p
->plist
= Fcopy_sequence (ps
->plist
);
4149 p
->sentinel
= ps
->sentinel
;
4150 p
->filter
= ps
->filter
;
4157 /* Client processes for accepted connections are not stopped initially. */
4158 if (!EQ (p
->filter
, Qt
))
4160 FD_SET (s
, &input_wait_mask
);
4161 FD_SET (s
, &non_keyboard_wait_mask
);
4164 if (s
> max_process_desc
)
4165 max_process_desc
= s
;
4167 /* Setup coding system for new process based on server process.
4168 This seems to be the proper thing to do, as the coding system
4169 of the new process should reflect the settings at the time the
4170 server socket was opened; not the current settings. */
4172 p
->decode_coding_system
= ps
->decode_coding_system
;
4173 p
->encode_coding_system
= ps
->encode_coding_system
;
4174 setup_process_coding_systems (proc
);
4176 p
->decoding_buf
= empty_unibyte_string
;
4177 p
->decoding_carryover
= 0;
4178 p
->encoding_buf
= empty_unibyte_string
;
4180 p
->inherit_coding_system_flag
4181 = (NILP (buffer
) ? 0 : ps
->inherit_coding_system_flag
);
4183 if (!NILP (ps
->log
))
4184 call3 (ps
->log
, server
, proc
,
4185 concat3 (build_string ("accept from "),
4186 (STRINGP (host
) ? host
: build_string ("-")),
4187 build_string ("\n")));
4189 if (!NILP (p
->sentinel
))
4190 exec_sentinel (proc
,
4191 concat3 (build_string ("open from "),
4192 (STRINGP (host
) ? host
: build_string ("-")),
4193 build_string ("\n")));
4196 /* This variable is different from waiting_for_input in keyboard.c.
4197 It is used to communicate to a lisp process-filter/sentinel (via the
4198 function Fwaiting_for_user_input_p below) whether Emacs was waiting
4199 for user-input when that process-filter was called.
4200 waiting_for_input cannot be used as that is by definition 0 when
4201 lisp code is being evalled.
4202 This is also used in record_asynch_buffer_change.
4203 For that purpose, this must be 0
4204 when not inside wait_reading_process_output. */
4205 static int waiting_for_user_input_p
;
4208 wait_reading_process_output_unwind (Lisp_Object data
)
4210 waiting_for_user_input_p
= XINT (data
);
4214 /* This is here so breakpoints can be put on it. */
4216 wait_reading_process_output_1 (void)
4220 /* Use a wrapper around select to work around a bug in gdb 5.3.
4221 Normally, the wrapper is optimized away by inlining.
4223 If emacs is stopped inside select, the gdb backtrace doesn't
4224 show the function which called select, so it is practically
4225 impossible to step through wait_reading_process_output. */
4229 select_wrapper (int n
, fd_set
*rfd
, fd_set
*wfd
, fd_set
*xfd
, struct timeval
*tmo
)
4231 return select (n
, rfd
, wfd
, xfd
, tmo
);
4233 #define select select_wrapper
4236 /* Read and dispose of subprocess output while waiting for timeout to
4237 elapse and/or keyboard input to be available.
4240 timeout in seconds, or
4241 zero for no limit, or
4242 -1 means gobble data immediately available but don't wait for any.
4245 an additional duration to wait, measured in microseconds.
4246 If this is nonzero and time_limit is 0, then the timeout
4247 consists of MICROSECS only.
4249 READ_KBD is a lisp value:
4250 0 to ignore keyboard input, or
4251 1 to return when input is available, or
4252 -1 meaning caller will actually read the input, so don't throw to
4253 the quit handler, or
4255 DO_DISPLAY != 0 means redisplay should be done to show subprocess
4256 output that arrives.
4258 If WAIT_FOR_CELL is a cons cell, wait until its car is non-nil
4259 (and gobble terminal input into the buffer if any arrives).
4261 If WAIT_PROC is specified, wait until something arrives from that
4262 process. The return value is true if we read some input from
4265 If JUST_WAIT_PROC is non-nil, handle only output from WAIT_PROC
4266 (suspending output from other processes). A negative value
4267 means don't run any timers either.
4269 If WAIT_PROC is specified, then the function returns true if we
4270 received input from that process before the timeout elapsed.
4271 Otherwise, return true if we received input from any process. */
4274 wait_reading_process_output (int time_limit
, int microsecs
, int read_kbd
,
4276 Lisp_Object wait_for_cell
,
4277 struct Lisp_Process
*wait_proc
, int just_wait_proc
)
4279 register int channel
, nfds
;
4280 SELECT_TYPE Available
;
4281 SELECT_TYPE Writeok
;
4283 int check_delay
, no_avail
;
4286 EMACS_TIME timeout
, end_time
;
4287 int wait_channel
= -1;
4288 int got_some_input
= 0;
4289 ptrdiff_t count
= SPECPDL_INDEX ();
4291 FD_ZERO (&Available
);
4294 if (time_limit
== 0 && microsecs
== 0 && wait_proc
&& !NILP (Vinhibit_quit
)
4295 && !(CONSP (wait_proc
->status
) && EQ (XCAR (wait_proc
->status
), Qexit
)))
4296 message ("Blocking call to accept-process-output with quit inhibited!!");
4298 /* If wait_proc is a process to watch, set wait_channel accordingly. */
4299 if (wait_proc
!= NULL
)
4300 wait_channel
= wait_proc
->infd
;
4302 record_unwind_protect (wait_reading_process_output_unwind
,
4303 make_number (waiting_for_user_input_p
));
4304 waiting_for_user_input_p
= read_kbd
;
4306 /* Since we may need to wait several times,
4307 compute the absolute time to return at. */
4308 if (time_limit
|| microsecs
)
4310 EMACS_GET_TIME (end_time
);
4311 EMACS_SET_SECS_USECS (timeout
, time_limit
, microsecs
);
4312 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
4317 int timeout_reduced_for_timers
= 0;
4319 /* If calling from keyboard input, do not quit
4320 since we want to return C-g as an input character.
4321 Otherwise, do pending quit if requested. */
4326 process_pending_signals ();
4329 /* Exit now if the cell we're waiting for became non-nil. */
4330 if (! NILP (wait_for_cell
) && ! NILP (XCAR (wait_for_cell
)))
4333 /* Compute time from now till when time limit is up */
4334 /* Exit if already run out */
4335 if (time_limit
== -1)
4337 /* -1 specified for timeout means
4338 gobble output available now
4339 but don't wait at all. */
4341 EMACS_SET_SECS_USECS (timeout
, 0, 0);
4343 else if (time_limit
|| microsecs
)
4345 EMACS_GET_TIME (timeout
);
4346 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
4347 if (EMACS_TIME_NEG_P (timeout
))
4352 EMACS_SET_SECS_USECS (timeout
, 100000, 0);
4355 /* Normally we run timers here.
4356 But not if wait_for_cell; in those cases,
4357 the wait is supposed to be short,
4358 and those callers cannot handle running arbitrary Lisp code here. */
4359 if (NILP (wait_for_cell
)
4360 && just_wait_proc
>= 0)
4362 EMACS_TIME timer_delay
;
4366 int old_timers_run
= timers_run
;
4367 struct buffer
*old_buffer
= current_buffer
;
4368 Lisp_Object old_window
= selected_window
;
4370 timer_delay
= timer_check ();
4372 /* If a timer has run, this might have changed buffers
4373 an alike. Make read_key_sequence aware of that. */
4374 if (timers_run
!= old_timers_run
4375 && (old_buffer
!= current_buffer
4376 || !EQ (old_window
, selected_window
))
4377 && waiting_for_user_input_p
== -1)
4378 record_asynch_buffer_change ();
4380 if (timers_run
!= old_timers_run
&& do_display
)
4381 /* We must retry, since a timer may have requeued itself
4382 and that could alter the time_delay. */
4383 redisplay_preserve_echo_area (9);
4387 while (!detect_input_pending ());
4389 /* If there is unread keyboard input, also return. */
4391 && requeued_events_pending_p ())
4394 if (! EMACS_TIME_NEG_P (timer_delay
) && time_limit
!= -1)
4396 EMACS_TIME difference
;
4397 EMACS_SUB_TIME (difference
, timer_delay
, timeout
);
4398 if (EMACS_TIME_NEG_P (difference
))
4400 timeout
= timer_delay
;
4401 timeout_reduced_for_timers
= 1;
4404 /* If time_limit is -1, we are not going to wait at all. */
4405 else if (time_limit
!= -1)
4407 /* This is so a breakpoint can be put here. */
4408 wait_reading_process_output_1 ();
4412 /* Cause C-g and alarm signals to take immediate action,
4413 and cause input available signals to zero out timeout.
4415 It is important that we do this before checking for process
4416 activity. If we get a SIGCHLD after the explicit checks for
4417 process activity, timeout is the only way we will know. */
4419 set_waiting_for_input (&timeout
);
4421 /* If status of something has changed, and no input is
4422 available, notify the user of the change right away. After
4423 this explicit check, we'll let the SIGCHLD handler zap
4424 timeout to get our attention. */
4425 if (update_tick
!= process_tick
)
4430 if (kbd_on_hold_p ())
4433 Atemp
= input_wait_mask
;
4436 EMACS_SET_SECS_USECS (timeout
, 0, 0);
4437 if ((select (max (max_process_desc
, max_input_desc
) + 1,
4439 #ifdef NON_BLOCKING_CONNECT
4440 (num_pending_connects
> 0 ? &Ctemp
: (SELECT_TYPE
*)0),
4444 (SELECT_TYPE
*)0, &timeout
)
4447 /* It's okay for us to do this and then continue with
4448 the loop, since timeout has already been zeroed out. */
4449 clear_waiting_for_input ();
4450 status_notify (NULL
);
4451 if (do_display
) redisplay_preserve_echo_area (13);
4455 /* Don't wait for output from a non-running process. Just
4456 read whatever data has already been received. */
4457 if (wait_proc
&& wait_proc
->raw_status_new
)
4458 update_status (wait_proc
);
4460 && ! EQ (wait_proc
->status
, Qrun
)
4461 && ! EQ (wait_proc
->status
, Qconnect
))
4463 int nread
, total_nread
= 0;
4465 clear_waiting_for_input ();
4466 XSETPROCESS (proc
, wait_proc
);
4468 /* Read data from the process, until we exhaust it. */
4469 while (wait_proc
->infd
>= 0)
4471 nread
= read_process_output (proc
, wait_proc
->infd
);
4478 total_nread
+= nread
;
4482 else if (nread
== -1 && EIO
== errno
)
4486 else if (nread
== -1 && EAGAIN
== errno
)
4490 else if (nread
== -1 && EWOULDBLOCK
== errno
)
4494 if (total_nread
> 0 && do_display
)
4495 redisplay_preserve_echo_area (10);
4500 /* Wait till there is something to do */
4502 if (wait_proc
&& just_wait_proc
)
4504 if (wait_proc
->infd
< 0) /* Terminated */
4506 FD_SET (wait_proc
->infd
, &Available
);
4510 else if (!NILP (wait_for_cell
))
4512 Available
= non_process_wait_mask
;
4519 Available
= non_keyboard_wait_mask
;
4521 Available
= input_wait_mask
;
4522 Writeok
= write_mask
;
4523 #ifdef SELECT_CANT_DO_WRITE_MASK
4528 check_delay
= wait_channel
>= 0 ? 0 : process_output_delay_count
;
4531 /* If frame size has changed or the window is newly mapped,
4532 redisplay now, before we start to wait. There is a race
4533 condition here; if a SIGIO arrives between now and the select
4534 and indicates that a frame is trashed, the select may block
4535 displaying a trashed screen. */
4536 if (frame_garbaged
&& do_display
)
4538 clear_waiting_for_input ();
4539 redisplay_preserve_echo_area (11);
4541 set_waiting_for_input (&timeout
);
4544 /* Skip the `select' call if input is available and we're
4545 waiting for keyboard input or a cell change (which can be
4546 triggered by processing X events). In the latter case, set
4547 nfds to 1 to avoid breaking the loop. */
4549 if ((read_kbd
|| !NILP (wait_for_cell
))
4550 && detect_input_pending ())
4552 nfds
= read_kbd
? 0 : 1;
4559 #ifdef ADAPTIVE_READ_BUFFERING
4560 /* Set the timeout for adaptive read buffering if any
4561 process has non-zero read_output_skip and non-zero
4562 read_output_delay, and we are not reading output for a
4563 specific wait_channel. It is not executed if
4564 Vprocess_adaptive_read_buffering is nil. */
4565 if (process_output_skip
&& check_delay
> 0)
4567 int usecs
= EMACS_USECS (timeout
);
4568 if (EMACS_SECS (timeout
) > 0 || usecs
> READ_OUTPUT_DELAY_MAX
)
4569 usecs
= READ_OUTPUT_DELAY_MAX
;
4570 for (channel
= 0; check_delay
> 0 && channel
<= max_process_desc
; channel
++)
4572 proc
= chan_process
[channel
];
4575 /* Find minimum non-zero read_output_delay among the
4576 processes with non-zero read_output_skip. */
4577 if (XPROCESS (proc
)->read_output_delay
> 0)
4580 if (!XPROCESS (proc
)->read_output_skip
)
4582 FD_CLR (channel
, &Available
);
4583 XPROCESS (proc
)->read_output_skip
= 0;
4584 if (XPROCESS (proc
)->read_output_delay
< usecs
)
4585 usecs
= XPROCESS (proc
)->read_output_delay
;
4588 EMACS_SET_SECS_USECS (timeout
, 0, usecs
);
4589 process_output_skip
= 0;
4592 #if defined (USE_GTK) || defined (HAVE_GCONF) || defined (HAVE_GSETTINGS)
4594 #elif defined (HAVE_NS)
4599 (max (max_process_desc
, max_input_desc
) + 1,
4601 (check_write
? &Writeok
: (SELECT_TYPE
*)0),
4602 (SELECT_TYPE
*)0, &timeout
);
4605 /* GnuTLS buffers data internally. In lowat mode it leaves
4606 some data in the TCP buffers so that select works, but
4607 with custom pull/push functions we need to check if some
4608 data is available in the buffers manually. */
4610 wait_proc
&& wait_proc
->gnutls_p
/* Check for valid process. */
4611 /* Do we have pending data? */
4612 && emacs_gnutls_record_check_pending (wait_proc
->gnutls_state
) > 0)
4615 /* Set to Available. */
4616 FD_SET (wait_proc
->infd
, &Available
);
4623 /* Make C-g and alarm signals set flags again */
4624 clear_waiting_for_input ();
4626 /* If we woke up due to SIGWINCH, actually change size now. */
4627 do_pending_window_change (0);
4629 if (time_limit
&& nfds
== 0 && ! timeout_reduced_for_timers
)
4630 /* We wanted the full specified time, so return now. */
4634 if (xerrno
== EINTR
)
4636 else if (xerrno
== EBADF
)
4639 /* AIX doesn't handle PTY closure the same way BSD does. On AIX,
4640 the child's closure of the pts gives the parent a SIGHUP, and
4641 the ptc file descriptor is automatically closed,
4642 yielding EBADF here or at select() call above.
4643 So, SIGHUP is ignored (see def of PTY_TTY_NAME_SPRINTF
4644 in m/ibmrt-aix.h), and here we just ignore the select error.
4645 Cleanup occurs c/o status_notify after SIGCLD. */
4646 no_avail
= 1; /* Cannot depend on values returned */
4652 error ("select error: %s", emacs_strerror (xerrno
));
4657 FD_ZERO (&Available
);
4661 #if 0 /* When polling is used, interrupt_input is 0,
4662 so get_input_pending should read the input.
4663 So this should not be needed. */
4664 /* If we are using polling for input,
4665 and we see input available, make it get read now.
4666 Otherwise it might not actually get read for a second.
4667 And on hpux, since we turn off polling in wait_reading_process_output,
4668 it might never get read at all if we don't spend much time
4669 outside of wait_reading_process_output. */
4670 if (read_kbd
&& interrupt_input
4671 && keyboard_bit_set (&Available
)
4672 && input_polling_used ())
4673 kill (getpid (), SIGALRM
);
4676 /* Check for keyboard input */
4677 /* If there is any, return immediately
4678 to give it higher priority than subprocesses */
4682 int old_timers_run
= timers_run
;
4683 struct buffer
*old_buffer
= current_buffer
;
4684 Lisp_Object old_window
= selected_window
;
4687 if (detect_input_pending_run_timers (do_display
))
4689 swallow_events (do_display
);
4690 if (detect_input_pending_run_timers (do_display
))
4694 /* If a timer has run, this might have changed buffers
4695 an alike. Make read_key_sequence aware of that. */
4696 if (timers_run
!= old_timers_run
4697 && waiting_for_user_input_p
== -1
4698 && (old_buffer
!= current_buffer
4699 || !EQ (old_window
, selected_window
)))
4700 record_asynch_buffer_change ();
4706 /* If there is unread keyboard input, also return. */
4708 && requeued_events_pending_p ())
4711 /* If we are not checking for keyboard input now,
4712 do process events (but don't run any timers).
4713 This is so that X events will be processed.
4714 Otherwise they may have to wait until polling takes place.
4715 That would causes delays in pasting selections, for example.
4717 (We used to do this only if wait_for_cell.) */
4718 if (read_kbd
== 0 && detect_input_pending ())
4720 swallow_events (do_display
);
4721 #if 0 /* Exiting when read_kbd doesn't request that seems wrong, though. */
4722 if (detect_input_pending ())
4727 /* Exit now if the cell we're waiting for became non-nil. */
4728 if (! NILP (wait_for_cell
) && ! NILP (XCAR (wait_for_cell
)))
4732 /* If we think we have keyboard input waiting, but didn't get SIGIO,
4733 go read it. This can happen with X on BSD after logging out.
4734 In that case, there really is no input and no SIGIO,
4735 but select says there is input. */
4737 if (read_kbd
&& interrupt_input
4738 && keyboard_bit_set (&Available
) && ! noninteractive
)
4739 kill (getpid (), SIGIO
);
4743 got_some_input
|= nfds
> 0;
4745 /* If checking input just got us a size-change event from X,
4746 obey it now if we should. */
4747 if (read_kbd
|| ! NILP (wait_for_cell
))
4748 do_pending_window_change (0);
4750 /* Check for data from a process. */
4751 if (no_avail
|| nfds
== 0)
4754 for (channel
= 0; channel
<= max_input_desc
; ++channel
)
4756 struct fd_callback_data
*d
= &fd_callback_info
[channel
];
4757 if (FD_ISSET (channel
, &Available
)
4759 && (d
->condition
& FOR_READ
) != 0)
4760 d
->func (channel
, d
->data
, 1);
4761 if (FD_ISSET (channel
, &write_mask
)
4763 && (d
->condition
& FOR_WRITE
) != 0)
4764 d
->func (channel
, d
->data
, 0);
4767 for (channel
= 0; channel
<= max_process_desc
; channel
++)
4769 if (FD_ISSET (channel
, &Available
)
4770 && FD_ISSET (channel
, &non_keyboard_wait_mask
)
4771 && !FD_ISSET (channel
, &non_process_wait_mask
))
4775 /* If waiting for this channel, arrange to return as
4776 soon as no more input to be processed. No more
4778 if (wait_channel
== channel
)
4784 proc
= chan_process
[channel
];
4788 /* If this is a server stream socket, accept connection. */
4789 if (EQ (XPROCESS (proc
)->status
, Qlisten
))
4791 server_accept_connection (proc
, channel
);
4795 /* Read data from the process, starting with our
4796 buffered-ahead character if we have one. */
4798 nread
= read_process_output (proc
, channel
);
4801 /* Since read_process_output can run a filter,
4802 which can call accept-process-output,
4803 don't try to read from any other processes
4804 before doing the select again. */
4805 FD_ZERO (&Available
);
4808 redisplay_preserve_echo_area (12);
4811 else if (nread
== -1 && errno
== EWOULDBLOCK
)
4814 /* ISC 4.1 defines both EWOULDBLOCK and O_NONBLOCK,
4815 and Emacs uses O_NONBLOCK, so what we get is EAGAIN. */
4817 else if (nread
== -1 && errno
== EAGAIN
)
4821 else if (nread
== -1 && errno
== EAGAIN
)
4823 /* Note that we cannot distinguish between no input
4824 available now and a closed pipe.
4825 With luck, a closed pipe will be accompanied by
4826 subprocess termination and SIGCHLD. */
4827 else if (nread
== 0 && !NETCONN_P (proc
) && !SERIALCONN_P (proc
))
4829 #endif /* O_NDELAY */
4830 #endif /* O_NONBLOCK */
4832 /* On some OSs with ptys, when the process on one end of
4833 a pty exits, the other end gets an error reading with
4834 errno = EIO instead of getting an EOF (0 bytes read).
4835 Therefore, if we get an error reading and errno =
4836 EIO, just continue, because the child process has
4837 exited and should clean itself up soon (e.g. when we
4840 However, it has been known to happen that the SIGCHLD
4841 got lost. So raise the signal again just in case.
4843 else if (nread
== -1 && errno
== EIO
)
4845 /* Clear the descriptor now, so we only raise the signal once. */
4846 FD_CLR (channel
, &input_wait_mask
);
4847 FD_CLR (channel
, &non_keyboard_wait_mask
);
4849 kill (getpid (), SIGCHLD
);
4851 #endif /* HAVE_PTYS */
4852 /* If we can detect process termination, don't consider the process
4853 gone just because its pipe is closed. */
4855 else if (nread
== 0 && !NETCONN_P (proc
) && !SERIALCONN_P (proc
))
4860 /* Preserve status of processes already terminated. */
4861 XPROCESS (proc
)->tick
= ++process_tick
;
4862 deactivate_process (proc
);
4863 if (XPROCESS (proc
)->raw_status_new
)
4864 update_status (XPROCESS (proc
));
4865 if (EQ (XPROCESS (proc
)->status
, Qrun
))
4866 XPROCESS (proc
)->status
4867 = Fcons (Qexit
, Fcons (make_number (256), Qnil
));
4870 #ifdef NON_BLOCKING_CONNECT
4871 if (FD_ISSET (channel
, &Writeok
)
4872 && FD_ISSET (channel
, &connect_wait_mask
))
4874 struct Lisp_Process
*p
;
4876 FD_CLR (channel
, &connect_wait_mask
);
4877 FD_CLR (channel
, &write_mask
);
4878 if (--num_pending_connects
< 0)
4881 proc
= chan_process
[channel
];
4885 p
= XPROCESS (proc
);
4888 /* getsockopt(,,SO_ERROR,,) is said to hang on some systems.
4889 So only use it on systems where it is known to work. */
4891 socklen_t xlen
= sizeof (xerrno
);
4892 if (getsockopt (channel
, SOL_SOCKET
, SO_ERROR
, &xerrno
, &xlen
))
4897 struct sockaddr pname
;
4898 int pnamelen
= sizeof (pname
);
4900 /* If connection failed, getpeername will fail. */
4902 if (getpeername (channel
, &pname
, &pnamelen
) < 0)
4904 /* Obtain connect failure code through error slippage. */
4907 if (errno
== ENOTCONN
&& read (channel
, &dummy
, 1) < 0)
4914 p
->tick
= ++process_tick
;
4915 p
->status
= Fcons (Qfailed
, Fcons (make_number (xerrno
), Qnil
));
4916 deactivate_process (proc
);
4921 /* Execute the sentinel here. If we had relied on
4922 status_notify to do it later, it will read input
4923 from the process before calling the sentinel. */
4924 exec_sentinel (proc
, build_string ("open\n"));
4925 if (!EQ (p
->filter
, Qt
) && !EQ (p
->command
, Qt
))
4927 FD_SET (p
->infd
, &input_wait_mask
);
4928 FD_SET (p
->infd
, &non_keyboard_wait_mask
);
4932 #endif /* NON_BLOCKING_CONNECT */
4933 } /* end for each file descriptor */
4934 } /* end while exit conditions not met */
4936 unbind_to (count
, Qnil
);
4938 /* If calling from keyboard input, do not quit
4939 since we want to return C-g as an input character.
4940 Otherwise, do pending quit if requested. */
4943 /* Prevent input_pending from remaining set if we quit. */
4944 clear_input_pending ();
4948 return got_some_input
;
4951 /* Given a list (FUNCTION ARGS...), apply FUNCTION to the ARGS. */
4954 read_process_output_call (Lisp_Object fun_and_args
)
4956 return apply1 (XCAR (fun_and_args
), XCDR (fun_and_args
));
4960 read_process_output_error_handler (Lisp_Object error_val
)
4962 cmd_error_internal (error_val
, "error in process filter: ");
4964 update_echo_area ();
4965 Fsleep_for (make_number (2), Qnil
);
4969 /* Read pending output from the process channel,
4970 starting with our buffered-ahead character if we have one.
4971 Yield number of decoded characters read.
4973 This function reads at most 4096 characters.
4974 If you want to read all available subprocess output,
4975 you must call it repeatedly until it returns zero.
4977 The characters read are decoded according to PROC's coding-system
4981 read_process_output (Lisp_Object proc
, register int channel
)
4983 register ssize_t nbytes
;
4985 register Lisp_Object outstream
;
4986 register struct Lisp_Process
*p
= XPROCESS (proc
);
4987 register ptrdiff_t opoint
;
4988 struct coding_system
*coding
= proc_decode_coding_system
[channel
];
4989 int carryover
= p
->decoding_carryover
;
4991 ptrdiff_t count
= SPECPDL_INDEX ();
4992 Lisp_Object odeactivate
;
4994 chars
= (char *) alloca (carryover
+ readmax
);
4996 /* See the comment above. */
4997 memcpy (chars
, SDATA (p
->decoding_buf
), carryover
);
4999 #ifdef DATAGRAM_SOCKETS
5000 /* We have a working select, so proc_buffered_char is always -1. */
5001 if (DATAGRAM_CHAN_P (channel
))
5003 socklen_t len
= datagram_address
[channel
].len
;
5004 nbytes
= recvfrom (channel
, chars
+ carryover
, readmax
,
5005 0, datagram_address
[channel
].sa
, &len
);
5010 int buffered
= 0 <= proc_buffered_char
[channel
];
5013 chars
[carryover
] = proc_buffered_char
[channel
];
5014 proc_buffered_char
[channel
] = -1;
5017 if (XPROCESS (proc
)->gnutls_p
)
5018 nbytes
= emacs_gnutls_read (XPROCESS (proc
),
5019 chars
+ carryover
+ buffered
,
5020 readmax
- buffered
);
5023 nbytes
= emacs_read (channel
, chars
+ carryover
+ buffered
,
5024 readmax
- buffered
);
5025 #ifdef ADAPTIVE_READ_BUFFERING
5026 if (nbytes
> 0 && p
->adaptive_read_buffering
)
5028 int delay
= p
->read_output_delay
;
5031 if (delay
< READ_OUTPUT_DELAY_MAX_MAX
)
5034 process_output_delay_count
++;
5035 delay
+= READ_OUTPUT_DELAY_INCREMENT
* 2;
5038 else if (delay
> 0 && nbytes
== readmax
- buffered
)
5040 delay
-= READ_OUTPUT_DELAY_INCREMENT
;
5042 process_output_delay_count
--;
5044 p
->read_output_delay
= delay
;
5047 p
->read_output_skip
= 1;
5048 process_output_skip
= 1;
5053 nbytes
+= buffered
&& nbytes
<= 0;
5056 p
->decoding_carryover
= 0;
5058 /* At this point, NBYTES holds number of bytes just received
5059 (including the one in proc_buffered_char[channel]). */
5062 if (nbytes
< 0 || coding
->mode
& CODING_MODE_LAST_BLOCK
)
5064 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
5067 /* Now set NBYTES how many bytes we must decode. */
5068 nbytes
+= carryover
;
5070 odeactivate
= Vdeactivate_mark
;
5071 /* There's no good reason to let process filters change the current
5072 buffer, and many callers of accept-process-output, sit-for, and
5073 friends don't expect current-buffer to be changed from under them. */
5074 record_unwind_protect (set_buffer_if_live
, Fcurrent_buffer ());
5076 /* Read and dispose of the process output. */
5077 outstream
= p
->filter
;
5078 if (!NILP (outstream
))
5081 int outer_running_asynch_code
= running_asynch_code
;
5082 int waiting
= waiting_for_user_input_p
;
5084 /* No need to gcpro these, because all we do with them later
5085 is test them for EQness, and none of them should be a string. */
5087 Lisp_Object obuffer
, okeymap
;
5088 XSETBUFFER (obuffer
, current_buffer
);
5089 okeymap
= BVAR (current_buffer
, keymap
);
5092 /* We inhibit quit here instead of just catching it so that
5093 hitting ^G when a filter happens to be running won't screw
5095 specbind (Qinhibit_quit
, Qt
);
5096 specbind (Qlast_nonmenu_event
, Qt
);
5098 /* In case we get recursively called,
5099 and we already saved the match data nonrecursively,
5100 save the same match data in safely recursive fashion. */
5101 if (outer_running_asynch_code
)
5104 /* Don't clobber the CURRENT match data, either! */
5105 tem
= Fmatch_data (Qnil
, Qnil
, Qnil
);
5106 restore_search_regs ();
5107 record_unwind_save_match_data ();
5108 Fset_match_data (tem
, Qt
);
5111 /* For speed, if a search happens within this code,
5112 save the match data in a special nonrecursive fashion. */
5113 running_asynch_code
= 1;
5115 decode_coding_c_string (coding
, (unsigned char *) chars
, nbytes
, Qt
);
5116 text
= coding
->dst_object
;
5117 Vlast_coding_system_used
= CODING_ID_NAME (coding
->id
);
5118 /* A new coding system might be found. */
5119 if (!EQ (p
->decode_coding_system
, Vlast_coding_system_used
))
5121 p
->decode_coding_system
= Vlast_coding_system_used
;
5123 /* Don't call setup_coding_system for
5124 proc_decode_coding_system[channel] here. It is done in
5125 detect_coding called via decode_coding above. */
5127 /* If a coding system for encoding is not yet decided, we set
5128 it as the same as coding-system for decoding.
5130 But, before doing that we must check if
5131 proc_encode_coding_system[p->outfd] surely points to a
5132 valid memory because p->outfd will be changed once EOF is
5133 sent to the process. */
5134 if (NILP (p
->encode_coding_system
)
5135 && proc_encode_coding_system
[p
->outfd
])
5137 p
->encode_coding_system
5138 = coding_inherit_eol_type (Vlast_coding_system_used
, Qnil
);
5139 setup_coding_system (p
->encode_coding_system
,
5140 proc_encode_coding_system
[p
->outfd
]);
5144 if (coding
->carryover_bytes
> 0)
5146 if (SCHARS (p
->decoding_buf
) < coding
->carryover_bytes
)
5147 p
->decoding_buf
= make_uninit_string (coding
->carryover_bytes
);
5148 memcpy (SDATA (p
->decoding_buf
), coding
->carryover
,
5149 coding
->carryover_bytes
);
5150 p
->decoding_carryover
= coding
->carryover_bytes
;
5152 if (SBYTES (text
) > 0)
5153 /* FIXME: It's wrong to wrap or not based on debug-on-error, and
5154 sometimes it's simply wrong to wrap (e.g. when called from
5155 accept-process-output). */
5156 internal_condition_case_1 (read_process_output_call
,
5158 Fcons (proc
, Fcons (text
, Qnil
))),
5159 !NILP (Vdebug_on_error
) ? Qnil
: Qerror
,
5160 read_process_output_error_handler
);
5162 /* If we saved the match data nonrecursively, restore it now. */
5163 restore_search_regs ();
5164 running_asynch_code
= outer_running_asynch_code
;
5166 /* Restore waiting_for_user_input_p as it was
5167 when we were called, in case the filter clobbered it. */
5168 waiting_for_user_input_p
= waiting
;
5170 #if 0 /* Call record_asynch_buffer_change unconditionally,
5171 because we might have changed minor modes or other things
5172 that affect key bindings. */
5173 if (! EQ (Fcurrent_buffer (), obuffer
)
5174 || ! EQ (current_buffer
->keymap
, okeymap
))
5176 /* But do it only if the caller is actually going to read events.
5177 Otherwise there's no need to make him wake up, and it could
5178 cause trouble (for example it would make sit_for return). */
5179 if (waiting_for_user_input_p
== -1)
5180 record_asynch_buffer_change ();
5183 /* If no filter, write into buffer if it isn't dead. */
5184 else if (!NILP (p
->buffer
) && !NILP (BVAR (XBUFFER (p
->buffer
), name
)))
5186 Lisp_Object old_read_only
;
5187 ptrdiff_t old_begv
, old_zv
;
5188 ptrdiff_t old_begv_byte
, old_zv_byte
;
5189 ptrdiff_t before
, before_byte
;
5190 ptrdiff_t opoint_byte
;
5194 Fset_buffer (p
->buffer
);
5196 opoint_byte
= PT_BYTE
;
5197 old_read_only
= BVAR (current_buffer
, read_only
);
5200 old_begv_byte
= BEGV_BYTE
;
5201 old_zv_byte
= ZV_BYTE
;
5203 BVAR (current_buffer
, read_only
) = Qnil
;
5205 /* Insert new output into buffer
5206 at the current end-of-output marker,
5207 thus preserving logical ordering of input and output. */
5208 if (XMARKER (p
->mark
)->buffer
)
5209 SET_PT_BOTH (clip_to_bounds (BEGV
, marker_position (p
->mark
), ZV
),
5210 clip_to_bounds (BEGV_BYTE
, marker_byte_position (p
->mark
),
5213 SET_PT_BOTH (ZV
, ZV_BYTE
);
5215 before_byte
= PT_BYTE
;
5217 /* If the output marker is outside of the visible region, save
5218 the restriction and widen. */
5219 if (! (BEGV
<= PT
&& PT
<= ZV
))
5222 decode_coding_c_string (coding
, (unsigned char *) chars
, nbytes
, Qt
);
5223 text
= coding
->dst_object
;
5224 Vlast_coding_system_used
= CODING_ID_NAME (coding
->id
);
5225 /* A new coding system might be found. See the comment in the
5226 similar code in the previous `if' block. */
5227 if (!EQ (p
->decode_coding_system
, Vlast_coding_system_used
))
5229 p
->decode_coding_system
= Vlast_coding_system_used
;
5230 if (NILP (p
->encode_coding_system
)
5231 && proc_encode_coding_system
[p
->outfd
])
5233 p
->encode_coding_system
5234 = coding_inherit_eol_type (Vlast_coding_system_used
, Qnil
);
5235 setup_coding_system (p
->encode_coding_system
,
5236 proc_encode_coding_system
[p
->outfd
]);
5239 if (coding
->carryover_bytes
> 0)
5241 if (SCHARS (p
->decoding_buf
) < coding
->carryover_bytes
)
5242 p
->decoding_buf
= make_uninit_string (coding
->carryover_bytes
);
5243 memcpy (SDATA (p
->decoding_buf
), coding
->carryover
,
5244 coding
->carryover_bytes
);
5245 p
->decoding_carryover
= coding
->carryover_bytes
;
5247 /* Adjust the multibyteness of TEXT to that of the buffer. */
5248 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
))
5249 != ! STRING_MULTIBYTE (text
))
5250 text
= (STRING_MULTIBYTE (text
)
5251 ? Fstring_as_unibyte (text
)
5252 : Fstring_to_multibyte (text
));
5253 /* Insert before markers in case we are inserting where
5254 the buffer's mark is, and the user's next command is Meta-y. */
5255 insert_from_string_before_markers (text
, 0, 0,
5256 SCHARS (text
), SBYTES (text
), 0);
5258 /* Make sure the process marker's position is valid when the
5259 process buffer is changed in the signal_after_change above.
5260 W3 is known to do that. */
5261 if (BUFFERP (p
->buffer
)
5262 && (b
= XBUFFER (p
->buffer
), b
!= current_buffer
))
5263 set_marker_both (p
->mark
, p
->buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
5265 set_marker_both (p
->mark
, p
->buffer
, PT
, PT_BYTE
);
5267 update_mode_lines
++;
5269 /* Make sure opoint and the old restrictions
5270 float ahead of any new text just as point would. */
5271 if (opoint
>= before
)
5273 opoint
+= PT
- before
;
5274 opoint_byte
+= PT_BYTE
- before_byte
;
5276 if (old_begv
> before
)
5278 old_begv
+= PT
- before
;
5279 old_begv_byte
+= PT_BYTE
- before_byte
;
5281 if (old_zv
>= before
)
5283 old_zv
+= PT
- before
;
5284 old_zv_byte
+= PT_BYTE
- before_byte
;
5287 /* If the restriction isn't what it should be, set it. */
5288 if (old_begv
!= BEGV
|| old_zv
!= ZV
)
5289 Fnarrow_to_region (make_number (old_begv
), make_number (old_zv
));
5292 BVAR (current_buffer
, read_only
) = old_read_only
;
5293 SET_PT_BOTH (opoint
, opoint_byte
);
5295 /* Handling the process output should not deactivate the mark. */
5296 Vdeactivate_mark
= odeactivate
;
5298 unbind_to (count
, Qnil
);
5302 /* Sending data to subprocess */
5304 static jmp_buf send_process_frame
;
5305 static Lisp_Object process_sent_to
;
5307 #ifndef FORWARD_SIGNAL_TO_MAIN_THREAD
5308 static void send_process_trap (int) NO_RETURN
;
5312 send_process_trap (int ignore
)
5314 SIGNAL_THREAD_CHECK (SIGPIPE
);
5315 sigunblock (sigmask (SIGPIPE
));
5316 longjmp (send_process_frame
, 1);
5319 /* Send some data to process PROC.
5320 BUF is the beginning of the data; LEN is the number of characters.
5321 OBJECT is the Lisp object that the data comes from. If OBJECT is
5322 nil or t, it means that the data comes from C string.
5324 If OBJECT is not nil, the data is encoded by PROC's coding-system
5325 for encoding before it is sent.
5327 This function can evaluate Lisp code and can garbage collect. */
5330 send_process (volatile Lisp_Object proc
, const char *volatile buf
,
5331 volatile ptrdiff_t len
, volatile Lisp_Object object
)
5333 /* Use volatile to protect variables from being clobbered by longjmp. */
5334 struct Lisp_Process
*p
= XPROCESS (proc
);
5336 struct coding_system
*coding
;
5337 struct gcpro gcpro1
;
5338 void (*volatile old_sigpipe
) (int);
5342 if (p
->raw_status_new
)
5344 if (! EQ (p
->status
, Qrun
))
5345 error ("Process %s not running", SDATA (p
->name
));
5347 error ("Output file descriptor of %s is closed", SDATA (p
->name
));
5349 coding
= proc_encode_coding_system
[p
->outfd
];
5350 Vlast_coding_system_used
= CODING_ID_NAME (coding
->id
);
5352 if ((STRINGP (object
) && STRING_MULTIBYTE (object
))
5353 || (BUFFERP (object
)
5354 && !NILP (BVAR (XBUFFER (object
), enable_multibyte_characters
)))
5357 p
->encode_coding_system
5358 = complement_process_encoding_system (p
->encode_coding_system
);
5359 if (!EQ (Vlast_coding_system_used
, p
->encode_coding_system
))
5361 /* The coding system for encoding was changed to raw-text
5362 because we sent a unibyte text previously. Now we are
5363 sending a multibyte text, thus we must encode it by the
5364 original coding system specified for the current process.
5366 Another reason we come here is that the coding system
5367 was just complemented and a new one was returned by
5368 complement_process_encoding_system. */
5369 setup_coding_system (p
->encode_coding_system
, coding
);
5370 Vlast_coding_system_used
= p
->encode_coding_system
;
5372 coding
->src_multibyte
= 1;
5376 coding
->src_multibyte
= 0;
5377 /* For sending a unibyte text, character code conversion should
5378 not take place but EOL conversion should. So, setup raw-text
5379 or one of the subsidiary if we have not yet done it. */
5380 if (CODING_REQUIRE_ENCODING (coding
))
5382 if (CODING_REQUIRE_FLUSHING (coding
))
5384 /* But, before changing the coding, we must flush out data. */
5385 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
5386 send_process (proc
, "", 0, Qt
);
5387 coding
->mode
&= CODING_MODE_LAST_BLOCK
;
5389 setup_coding_system (raw_text_coding_system
5390 (Vlast_coding_system_used
),
5392 coding
->src_multibyte
= 0;
5395 coding
->dst_multibyte
= 0;
5397 if (CODING_REQUIRE_ENCODING (coding
))
5399 coding
->dst_object
= Qt
;
5400 if (BUFFERP (object
))
5402 ptrdiff_t from_byte
, from
, to
;
5403 ptrdiff_t save_pt
, save_pt_byte
;
5404 struct buffer
*cur
= current_buffer
;
5406 set_buffer_internal (XBUFFER (object
));
5407 save_pt
= PT
, save_pt_byte
= PT_BYTE
;
5409 from_byte
= PTR_BYTE_POS ((unsigned char *) buf
);
5410 from
= BYTE_TO_CHAR (from_byte
);
5411 to
= BYTE_TO_CHAR (from_byte
+ len
);
5412 TEMP_SET_PT_BOTH (from
, from_byte
);
5413 encode_coding_object (coding
, object
, from
, from_byte
,
5414 to
, from_byte
+ len
, Qt
);
5415 TEMP_SET_PT_BOTH (save_pt
, save_pt_byte
);
5416 set_buffer_internal (cur
);
5418 else if (STRINGP (object
))
5420 encode_coding_object (coding
, object
, 0, 0, SCHARS (object
),
5421 SBYTES (object
), Qt
);
5425 coding
->dst_object
= make_unibyte_string (buf
, len
);
5426 coding
->produced
= len
;
5429 len
= coding
->produced
;
5430 object
= coding
->dst_object
;
5431 buf
= SSDATA (object
);
5434 if (pty_max_bytes
== 0)
5436 #if defined (HAVE_FPATHCONF) && defined (_PC_MAX_CANON)
5437 pty_max_bytes
= fpathconf (p
->outfd
, _PC_MAX_CANON
);
5438 if (pty_max_bytes
< 0)
5439 pty_max_bytes
= 250;
5441 pty_max_bytes
= 250;
5443 /* Deduct one, to leave space for the eof. */
5447 /* 2000-09-21: Emacs 20.7, sparc-sun-solaris-2.6, GCC 2.95.2,
5448 CFLAGS="-g -O": The value of the parameter `proc' is clobbered
5449 when returning with longjmp despite being declared volatile. */
5450 if (!setjmp (send_process_frame
))
5452 p
= XPROCESS (proc
); /* Repair any setjmp clobbering. */
5454 process_sent_to
= proc
;
5457 ptrdiff_t this = len
;
5459 /* Send this batch, using one or more write calls. */
5462 ptrdiff_t written
= 0;
5463 int outfd
= p
->outfd
;
5464 old_sigpipe
= (void (*) (int)) signal (SIGPIPE
, send_process_trap
);
5465 #ifdef DATAGRAM_SOCKETS
5466 if (DATAGRAM_CHAN_P (outfd
))
5468 rv
= sendto (outfd
, buf
, this,
5469 0, datagram_address
[outfd
].sa
,
5470 datagram_address
[outfd
].len
);
5473 else if (errno
== EMSGSIZE
)
5475 signal (SIGPIPE
, old_sigpipe
);
5476 report_file_error ("sending datagram",
5477 Fcons (proc
, Qnil
));
5484 if (XPROCESS (proc
)->gnutls_p
)
5485 written
= emacs_gnutls_write (XPROCESS (proc
),
5489 written
= emacs_write (outfd
, buf
, this);
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;
5501 signal (SIGPIPE
, old_sigpipe
);
5507 || errno
== EWOULDBLOCK
5513 /* Buffer is full. Wait, accepting input;
5514 that may allow the program
5515 to finish doing output and read more. */
5517 ptrdiff_t offset
= 0;
5519 #ifdef BROKEN_PTY_READ_AFTER_EAGAIN
5520 /* A gross hack to work around a bug in FreeBSD.
5521 In the following sequence, read(2) returns
5525 write(2) 954 bytes, get EAGAIN
5526 read(2) 1024 bytes in process_read_output
5527 read(2) 11 bytes in process_read_output
5529 That is, read(2) returns more bytes than have
5530 ever been written successfully. The 1033 bytes
5531 read are the 1022 bytes written successfully
5532 after processing (for example with CRs added if
5533 the terminal is set up that way which it is
5534 here). The same bytes will be seen again in a
5535 later read(2), without the CRs. */
5537 if (errno
== EAGAIN
)
5540 ioctl (p
->outfd
, TIOCFLUSH
, &flags
);
5542 #endif /* BROKEN_PTY_READ_AFTER_EAGAIN */
5544 /* Running filters might relocate buffers or strings.
5545 Arrange to relocate BUF. */
5546 if (BUFFERP (object
))
5547 offset
= BUF_PTR_BYTE_POS (XBUFFER (object
),
5548 (unsigned char *) buf
);
5549 else if (STRINGP (object
))
5550 offset
= buf
- SSDATA (object
);
5552 #ifdef EMACS_HAS_USECS
5553 wait_reading_process_output (0, 20000, 0, 0, Qnil
, NULL
, 0);
5555 wait_reading_process_output (1, 0, 0, 0, Qnil
, NULL
, 0);
5558 if (BUFFERP (object
))
5559 buf
= (char *) BUF_BYTE_ADDRESS (XBUFFER (object
),
5561 else if (STRINGP (object
))
5562 buf
= offset
+ SSDATA (object
);
5565 /* This is a real error. */
5566 report_file_error ("writing to process", Fcons (proc
, Qnil
));
5576 signal (SIGPIPE
, old_sigpipe
);
5577 proc
= process_sent_to
;
5578 p
= XPROCESS (proc
);
5579 p
->raw_status_new
= 0;
5580 p
->status
= Fcons (Qexit
, Fcons (make_number (256), Qnil
));
5581 p
->tick
= ++process_tick
;
5582 deactivate_process (proc
);
5583 error ("SIGPIPE raised on process %s; closed it", SDATA (p
->name
));
5589 DEFUN ("process-send-region", Fprocess_send_region
, Sprocess_send_region
,
5591 doc
: /* Send current contents of region as input to PROCESS.
5592 PROCESS may be a process, a buffer, the name of a process or buffer, or
5593 nil, indicating the current buffer's process.
5594 Called from program, takes three arguments, PROCESS, START and END.
5595 If the region is more than 500 characters long,
5596 it is sent in several bunches. This may happen even for shorter regions.
5597 Output from processes can arrive in between bunches. */)
5598 (Lisp_Object process
, Lisp_Object start
, Lisp_Object end
)
5601 ptrdiff_t start1
, end1
;
5603 proc
= get_process (process
);
5604 validate_region (&start
, &end
);
5606 if (XINT (start
) < GPT
&& XINT (end
) > GPT
)
5607 move_gap (XINT (start
));
5609 start1
= CHAR_TO_BYTE (XINT (start
));
5610 end1
= CHAR_TO_BYTE (XINT (end
));
5611 send_process (proc
, (char *) BYTE_POS_ADDR (start1
), end1
- start1
,
5612 Fcurrent_buffer ());
5617 DEFUN ("process-send-string", Fprocess_send_string
, Sprocess_send_string
,
5619 doc
: /* Send PROCESS the contents of STRING as input.
5620 PROCESS may be a process, a buffer, the name of a process or buffer, or
5621 nil, indicating the current buffer's process.
5622 If STRING is more than 500 characters long,
5623 it is sent in several bunches. This may happen even for shorter strings.
5624 Output from processes can arrive in between bunches. */)
5625 (Lisp_Object process
, Lisp_Object string
)
5628 CHECK_STRING (string
);
5629 proc
= get_process (process
);
5630 send_process (proc
, SSDATA (string
),
5631 SBYTES (string
), string
);
5635 /* Return the foreground process group for the tty/pty that
5636 the process P uses. */
5638 emacs_get_tty_pgrp (struct Lisp_Process
*p
)
5643 if (ioctl (p
->infd
, TIOCGPGRP
, &gid
) == -1 && ! NILP (p
->tty_name
))
5646 /* Some OS:es (Solaris 8/9) does not allow TIOCGPGRP from the
5647 master side. Try the slave side. */
5648 fd
= emacs_open (SSDATA (p
->tty_name
), O_RDONLY
, 0);
5652 ioctl (fd
, TIOCGPGRP
, &gid
);
5656 #endif /* defined (TIOCGPGRP ) */
5661 DEFUN ("process-running-child-p", Fprocess_running_child_p
,
5662 Sprocess_running_child_p
, 0, 1, 0,
5663 doc
: /* Return t if PROCESS has given the terminal to a child.
5664 If the operating system does not make it possible to find out,
5665 return t unconditionally. */)
5666 (Lisp_Object process
)
5668 /* Initialize in case ioctl doesn't exist or gives an error,
5669 in a way that will cause returning t. */
5672 struct Lisp_Process
*p
;
5674 proc
= get_process (process
);
5675 p
= XPROCESS (proc
);
5677 if (!EQ (p
->type
, Qreal
))
5678 error ("Process %s is not a subprocess",
5681 error ("Process %s is not active",
5684 gid
= emacs_get_tty_pgrp (p
);
5691 /* send a signal number SIGNO to PROCESS.
5692 If CURRENT_GROUP is t, that means send to the process group
5693 that currently owns the terminal being used to communicate with PROCESS.
5694 This is used for various commands in shell mode.
5695 If CURRENT_GROUP is lambda, that means send to the process group
5696 that currently owns the terminal, but only if it is NOT the shell itself.
5698 If NOMSG is zero, insert signal-announcements into process's buffers
5701 If we can, we try to signal PROCESS by sending control characters
5702 down the pty. This allows us to signal inferiors who have changed
5703 their uid, for which killpg would return an EPERM error. */
5706 process_send_signal (Lisp_Object process
, int signo
, Lisp_Object current_group
,
5710 register struct Lisp_Process
*p
;
5714 proc
= get_process (process
);
5715 p
= XPROCESS (proc
);
5717 if (!EQ (p
->type
, Qreal
))
5718 error ("Process %s is not a subprocess",
5721 error ("Process %s is not active",
5725 current_group
= Qnil
;
5727 /* If we are using pgrps, get a pgrp number and make it negative. */
5728 if (NILP (current_group
))
5729 /* Send the signal to the shell's process group. */
5733 #ifdef SIGNALS_VIA_CHARACTERS
5734 /* If possible, send signals to the entire pgrp
5735 by sending an input character to it. */
5738 cc_t
*sig_char
= NULL
;
5740 tcgetattr (p
->infd
, &t
);
5745 sig_char
= &t
.c_cc
[VINTR
];
5749 sig_char
= &t
.c_cc
[VQUIT
];
5753 #if defined (VSWTCH) && !defined (PREFER_VSUSP)
5754 sig_char
= &t
.c_cc
[VSWTCH
];
5756 sig_char
= &t
.c_cc
[VSUSP
];
5761 if (sig_char
&& *sig_char
!= CDISABLE
)
5763 send_process (proc
, (char *) sig_char
, 1, Qnil
);
5766 /* If we can't send the signal with a character,
5767 fall through and send it another way. */
5769 /* The code above may fall through if it can't
5770 handle the signal. */
5771 #endif /* defined (SIGNALS_VIA_CHARACTERS) */
5774 /* Get the current pgrp using the tty itself, if we have that.
5775 Otherwise, use the pty to get the pgrp.
5776 On pfa systems, saka@pfu.fujitsu.co.JP writes:
5777 "TIOCGPGRP symbol defined in sys/ioctl.h at E50.
5778 But, TIOCGPGRP does not work on E50 ;-P works fine on E60"
5779 His patch indicates that if TIOCGPGRP returns an error, then
5780 we should just assume that p->pid is also the process group id. */
5782 gid
= emacs_get_tty_pgrp (p
);
5785 /* If we can't get the information, assume
5786 the shell owns the tty. */
5789 /* It is not clear whether anything really can set GID to -1.
5790 Perhaps on some system one of those ioctls can or could do so.
5791 Or perhaps this is vestigial. */
5794 #else /* ! defined (TIOCGPGRP ) */
5795 /* Can't select pgrps on this system, so we know that
5796 the child itself heads the pgrp. */
5798 #endif /* ! defined (TIOCGPGRP ) */
5800 /* If current_group is lambda, and the shell owns the terminal,
5801 don't send any signal. */
5802 if (EQ (current_group
, Qlambda
) && gid
== p
->pid
)
5810 p
->raw_status_new
= 0;
5812 p
->tick
= ++process_tick
;
5815 status_notify (NULL
);
5816 redisplay_preserve_echo_area (13);
5819 #endif /* ! defined (SIGCONT) */
5823 flush_pending_output (p
->infd
);
5827 /* If we don't have process groups, send the signal to the immediate
5828 subprocess. That isn't really right, but it's better than any
5829 obvious alternative. */
5832 kill (p
->pid
, signo
);
5836 /* gid may be a pid, or minus a pgrp's number */
5838 if (!NILP (current_group
))
5840 if (ioctl (p
->infd
, TIOCSIGSEND
, signo
) == -1)
5841 EMACS_KILLPG (gid
, signo
);
5848 #else /* ! defined (TIOCSIGSEND) */
5849 EMACS_KILLPG (gid
, signo
);
5850 #endif /* ! defined (TIOCSIGSEND) */
5853 DEFUN ("interrupt-process", Finterrupt_process
, Sinterrupt_process
, 0, 2, 0,
5854 doc
: /* Interrupt process PROCESS.
5855 PROCESS may be a process, a buffer, or the name of a process or buffer.
5856 No arg or nil means current buffer's process.
5857 Second arg CURRENT-GROUP non-nil means send signal to
5858 the current process-group of the process's controlling terminal
5859 rather than to the process's own process group.
5860 If the process is a shell, this means interrupt current subjob
5861 rather than the shell.
5863 If CURRENT-GROUP is `lambda', and if the shell owns the terminal,
5864 don't send the signal. */)
5865 (Lisp_Object process
, Lisp_Object current_group
)
5867 process_send_signal (process
, SIGINT
, current_group
, 0);
5871 DEFUN ("kill-process", Fkill_process
, Skill_process
, 0, 2, 0,
5872 doc
: /* Kill process PROCESS. May be process or name of one.
5873 See function `interrupt-process' for more details on usage. */)
5874 (Lisp_Object process
, Lisp_Object current_group
)
5876 process_send_signal (process
, SIGKILL
, current_group
, 0);
5880 DEFUN ("quit-process", Fquit_process
, Squit_process
, 0, 2, 0,
5881 doc
: /* Send QUIT signal to process PROCESS. May be process or name of one.
5882 See function `interrupt-process' for more details on usage. */)
5883 (Lisp_Object process
, Lisp_Object current_group
)
5885 process_send_signal (process
, SIGQUIT
, current_group
, 0);
5889 DEFUN ("stop-process", Fstop_process
, Sstop_process
, 0, 2, 0,
5890 doc
: /* Stop process PROCESS. May be process or name of one.
5891 See function `interrupt-process' for more details on usage.
5892 If PROCESS is a network or serial process, inhibit handling of incoming
5894 (Lisp_Object process
, Lisp_Object current_group
)
5896 if (PROCESSP (process
) && (NETCONN_P (process
) || SERIALCONN_P (process
)))
5898 struct Lisp_Process
*p
;
5900 p
= XPROCESS (process
);
5901 if (NILP (p
->command
)
5904 FD_CLR (p
->infd
, &input_wait_mask
);
5905 FD_CLR (p
->infd
, &non_keyboard_wait_mask
);
5911 error ("No SIGTSTP support");
5913 process_send_signal (process
, SIGTSTP
, current_group
, 0);
5918 DEFUN ("continue-process", Fcontinue_process
, Scontinue_process
, 0, 2, 0,
5919 doc
: /* Continue process PROCESS. May be process or name of one.
5920 See function `interrupt-process' for more details on usage.
5921 If PROCESS is a network or serial process, resume handling of incoming
5923 (Lisp_Object process
, Lisp_Object current_group
)
5925 if (PROCESSP (process
) && (NETCONN_P (process
) || SERIALCONN_P (process
)))
5927 struct Lisp_Process
*p
;
5929 p
= XPROCESS (process
);
5930 if (EQ (p
->command
, Qt
)
5932 && (!EQ (p
->filter
, Qt
) || EQ (p
->status
, Qlisten
)))
5934 FD_SET (p
->infd
, &input_wait_mask
);
5935 FD_SET (p
->infd
, &non_keyboard_wait_mask
);
5937 if (fd_info
[ p
->infd
].flags
& FILE_SERIAL
)
5938 PurgeComm (fd_info
[ p
->infd
].hnd
, PURGE_RXABORT
| PURGE_RXCLEAR
);
5939 #else /* not WINDOWSNT */
5940 tcflush (p
->infd
, TCIFLUSH
);
5941 #endif /* not WINDOWSNT */
5947 process_send_signal (process
, SIGCONT
, current_group
, 0);
5949 error ("No SIGCONT support");
5954 DEFUN ("signal-process", Fsignal_process
, Ssignal_process
,
5955 2, 2, "sProcess (name or number): \nnSignal code: ",
5956 doc
: /* Send PROCESS the signal with code SIGCODE.
5957 PROCESS may also be a number specifying the process id of the
5958 process to signal; in this case, the process need not be a child of
5960 SIGCODE may be an integer, or a symbol whose name is a signal name. */)
5961 (Lisp_Object process
, Lisp_Object sigcode
)
5965 if (STRINGP (process
))
5967 Lisp_Object tem
= Fget_process (process
);
5970 Lisp_Object process_number
=
5971 string_to_number (SSDATA (process
), 10, 1);
5972 if (INTEGERP (process_number
) || FLOATP (process_number
))
5973 tem
= process_number
;
5977 else if (!NUMBERP (process
))
5978 process
= get_process (process
);
5983 if (NUMBERP (process
))
5984 CONS_TO_INTEGER (process
, pid_t
, pid
);
5987 CHECK_PROCESS (process
);
5988 pid
= XPROCESS (process
)->pid
;
5990 error ("Cannot signal process %s", SDATA (XPROCESS (process
)->name
));
5993 #define parse_signal(NAME, VALUE) \
5994 else if (!xstrcasecmp (name, NAME)) \
5995 XSETINT (sigcode, VALUE)
5997 if (INTEGERP (sigcode
))
5998 CHECK_TYPE_RANGED_INTEGER (int, sigcode
);
6003 CHECK_SYMBOL (sigcode
);
6004 name
= SSDATA (SYMBOL_NAME (sigcode
));
6006 if (!strncmp (name
, "SIG", 3) || !strncmp (name
, "sig", 3))
6012 parse_signal ("usr1", SIGUSR1
);
6015 parse_signal ("usr2", SIGUSR2
);
6018 parse_signal ("term", SIGTERM
);
6021 parse_signal ("hup", SIGHUP
);
6024 parse_signal ("int", SIGINT
);
6027 parse_signal ("quit", SIGQUIT
);
6030 parse_signal ("ill", SIGILL
);
6033 parse_signal ("abrt", SIGABRT
);
6036 parse_signal ("emt", SIGEMT
);
6039 parse_signal ("kill", SIGKILL
);
6042 parse_signal ("fpe", SIGFPE
);
6045 parse_signal ("bus", SIGBUS
);
6048 parse_signal ("segv", SIGSEGV
);
6051 parse_signal ("sys", SIGSYS
);
6054 parse_signal ("pipe", SIGPIPE
);
6057 parse_signal ("alrm", SIGALRM
);
6060 parse_signal ("urg", SIGURG
);
6063 parse_signal ("stop", SIGSTOP
);
6066 parse_signal ("tstp", SIGTSTP
);
6069 parse_signal ("cont", SIGCONT
);
6072 parse_signal ("chld", SIGCHLD
);
6075 parse_signal ("ttin", SIGTTIN
);
6078 parse_signal ("ttou", SIGTTOU
);
6081 parse_signal ("io", SIGIO
);
6084 parse_signal ("xcpu", SIGXCPU
);
6087 parse_signal ("xfsz", SIGXFSZ
);
6090 parse_signal ("vtalrm", SIGVTALRM
);
6093 parse_signal ("prof", SIGPROF
);
6096 parse_signal ("winch", SIGWINCH
);
6099 parse_signal ("info", SIGINFO
);
6102 error ("Undefined signal name %s", name
);
6107 return make_number (kill (pid
, XINT (sigcode
)));
6110 DEFUN ("process-send-eof", Fprocess_send_eof
, Sprocess_send_eof
, 0, 1, 0,
6111 doc
: /* Make PROCESS see end-of-file in its input.
6112 EOF comes after any text already sent to it.
6113 PROCESS may be a process, a buffer, the name of a process or buffer, or
6114 nil, indicating the current buffer's process.
6115 If PROCESS is a network connection, or is a process communicating
6116 through a pipe (as opposed to a pty), then you cannot send any more
6117 text to PROCESS after you call this function.
6118 If PROCESS is a serial process, wait until all output written to the
6119 process has been transmitted to the serial port. */)
6120 (Lisp_Object process
)
6123 struct coding_system
*coding
;
6125 if (DATAGRAM_CONN_P (process
))
6128 proc
= get_process (process
);
6129 coding
= proc_encode_coding_system
[XPROCESS (proc
)->outfd
];
6131 /* Make sure the process is really alive. */
6132 if (XPROCESS (proc
)->raw_status_new
)
6133 update_status (XPROCESS (proc
));
6134 if (! EQ (XPROCESS (proc
)->status
, Qrun
))
6135 error ("Process %s not running", SDATA (XPROCESS (proc
)->name
));
6137 if (CODING_REQUIRE_FLUSHING (coding
))
6139 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
6140 send_process (proc
, "", 0, Qnil
);
6143 if (XPROCESS (proc
)->pty_flag
)
6144 send_process (proc
, "\004", 1, Qnil
);
6145 else if (EQ (XPROCESS (proc
)->type
, Qserial
))
6148 if (tcdrain (XPROCESS (proc
)->outfd
) != 0)
6149 error ("tcdrain() failed: %s", emacs_strerror (errno
));
6150 #endif /* not WINDOWSNT */
6151 /* Do nothing on Windows because writes are blocking. */
6155 int old_outfd
, new_outfd
;
6157 #ifdef HAVE_SHUTDOWN
6158 /* If this is a network connection, or socketpair is used
6159 for communication with the subprocess, call shutdown to cause EOF.
6160 (In some old system, shutdown to socketpair doesn't work.
6161 Then we just can't win.) */
6162 if (EQ (XPROCESS (proc
)->type
, Qnetwork
)
6163 || XPROCESS (proc
)->outfd
== XPROCESS (proc
)->infd
)
6164 shutdown (XPROCESS (proc
)->outfd
, 1);
6165 /* In case of socketpair, outfd == infd, so don't close it. */
6166 if (XPROCESS (proc
)->outfd
!= XPROCESS (proc
)->infd
)
6167 emacs_close (XPROCESS (proc
)->outfd
);
6168 #else /* not HAVE_SHUTDOWN */
6169 emacs_close (XPROCESS (proc
)->outfd
);
6170 #endif /* not HAVE_SHUTDOWN */
6171 new_outfd
= emacs_open (NULL_DEVICE
, O_WRONLY
, 0);
6174 old_outfd
= XPROCESS (proc
)->outfd
;
6176 if (!proc_encode_coding_system
[new_outfd
])
6177 proc_encode_coding_system
[new_outfd
]
6178 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
6179 memcpy (proc_encode_coding_system
[new_outfd
],
6180 proc_encode_coding_system
[old_outfd
],
6181 sizeof (struct coding_system
));
6182 memset (proc_encode_coding_system
[old_outfd
], 0,
6183 sizeof (struct coding_system
));
6185 XPROCESS (proc
)->outfd
= new_outfd
;
6190 /* On receipt of a signal that a child status has changed, loop asking
6191 about children with changed statuses until the system says there
6194 All we do is change the status; we do not run sentinels or print
6195 notifications. That is saved for the next time keyboard input is
6196 done, in order to avoid timing errors.
6198 ** WARNING: this can be called during garbage collection.
6199 Therefore, it must not be fooled by the presence of mark bits in
6202 ** USG WARNING: Although it is not obvious from the documentation
6203 in signal(2), on a USG system the SIGCLD handler MUST NOT call
6204 signal() before executing at least one wait(), otherwise the
6205 handler will be called again, resulting in an infinite loop. The
6206 relevant portion of the documentation reads "SIGCLD signals will be
6207 queued and the signal-catching function will be continually
6208 reentered until the queue is empty". Invoking signal() causes the
6209 kernel to reexamine the SIGCLD queue. Fred Fish, UniSoft Systems
6212 ** Malloc WARNING: This should never call malloc either directly or
6213 indirectly; if it does, that is a bug */
6217 sigchld_handler (int signo
)
6219 int old_errno
= errno
;
6221 struct Lisp_Process
*p
;
6223 SIGNAL_THREAD_CHECK (signo
);
6234 #endif /* no WUNTRACED */
6235 /* Keep trying to get a status until we get a definitive result. */
6239 pid
= wait3 (&w
, WNOHANG
| WUNTRACED
, 0);
6241 while (pid
< 0 && errno
== EINTR
);
6245 /* PID == 0 means no processes found, PID == -1 means a real
6246 failure. We have done all our job, so return. */
6253 #endif /* no WNOHANG */
6255 /* Find the process that signaled us, and record its status. */
6257 /* The process can have been deleted by Fdelete_process. */
6258 for (tail
= deleted_pid_list
; CONSP (tail
); tail
= XCDR (tail
))
6260 Lisp_Object xpid
= XCAR (tail
);
6261 if ((INTEGERP (xpid
) && pid
== XINT (xpid
))
6262 || (FLOATP (xpid
) && pid
== XFLOAT_DATA (xpid
)))
6264 XSETCAR (tail
, Qnil
);
6265 goto sigchld_end_of_loop
;
6269 /* Otherwise, if it is asynchronous, it is in Vprocess_alist. */
6271 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
6273 proc
= XCDR (XCAR (tail
));
6274 p
= XPROCESS (proc
);
6275 if (EQ (p
->type
, Qreal
) && p
->pid
== pid
)
6280 /* Look for an asynchronous process whose pid hasn't been filled
6283 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
6285 proc
= XCDR (XCAR (tail
));
6286 p
= XPROCESS (proc
);
6292 /* Change the status of the process that was found. */
6295 int clear_desc_flag
= 0;
6297 p
->tick
= ++process_tick
;
6299 p
->raw_status_new
= 1;
6301 /* If process has terminated, stop waiting for its output. */
6302 if ((WIFSIGNALED (w
) || WIFEXITED (w
))
6304 clear_desc_flag
= 1;
6306 /* We use clear_desc_flag to avoid a compiler bug in Microsoft C. */
6307 if (clear_desc_flag
)
6309 FD_CLR (p
->infd
, &input_wait_mask
);
6310 FD_CLR (p
->infd
, &non_keyboard_wait_mask
);
6313 /* Tell wait_reading_process_output that it needs to wake up and
6315 if (input_available_clear_time
)
6316 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
6319 /* There was no asynchronous process found for that pid: we have
6320 a synchronous process. */
6323 synch_process_alive
= 0;
6325 /* Report the status of the synchronous process. */
6327 synch_process_retcode
= WRETCODE (w
);
6328 else if (WIFSIGNALED (w
))
6329 synch_process_termsig
= WTERMSIG (w
);
6331 /* Tell wait_reading_process_output that it needs to wake up and
6333 if (input_available_clear_time
)
6334 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
6337 sigchld_end_of_loop
:
6340 /* On some systems, we must return right away.
6341 If any more processes want to signal us, we will
6343 Otherwise (on systems that have WNOHANG), loop around
6344 to use up all the processes that have something to tell us. */
6345 #if (defined WINDOWSNT \
6346 || (defined USG && !defined GNU_LINUX \
6347 && !(defined HPUX && defined WNOHANG)))
6350 #endif /* USG, but not HPUX with WNOHANG */
6353 #endif /* SIGCHLD */
6357 exec_sentinel_unwind (Lisp_Object data
)
6359 XPROCESS (XCAR (data
))->sentinel
= XCDR (data
);
6364 exec_sentinel_error_handler (Lisp_Object error_val
)
6366 cmd_error_internal (error_val
, "error in process sentinel: ");
6368 update_echo_area ();
6369 Fsleep_for (make_number (2), Qnil
);
6374 exec_sentinel (Lisp_Object proc
, Lisp_Object reason
)
6376 Lisp_Object sentinel
, odeactivate
;
6377 register struct Lisp_Process
*p
= XPROCESS (proc
);
6378 ptrdiff_t count
= SPECPDL_INDEX ();
6379 int outer_running_asynch_code
= running_asynch_code
;
6380 int waiting
= waiting_for_user_input_p
;
6382 if (inhibit_sentinels
)
6385 /* No need to gcpro these, because all we do with them later
6386 is test them for EQness, and none of them should be a string. */
6387 odeactivate
= Vdeactivate_mark
;
6389 Lisp_Object obuffer
, okeymap
;
6390 XSETBUFFER (obuffer
, current_buffer
);
6391 okeymap
= BVAR (current_buffer
, keymap
);
6394 /* There's no good reason to let sentinels change the current
6395 buffer, and many callers of accept-process-output, sit-for, and
6396 friends don't expect current-buffer to be changed from under them. */
6397 record_unwind_protect (set_buffer_if_live
, Fcurrent_buffer ());
6399 sentinel
= p
->sentinel
;
6400 if (NILP (sentinel
))
6403 /* Zilch the sentinel while it's running, to avoid recursive invocations;
6404 assure that it gets restored no matter how the sentinel exits. */
6406 record_unwind_protect (exec_sentinel_unwind
, Fcons (proc
, sentinel
));
6407 /* Inhibit quit so that random quits don't screw up a running filter. */
6408 specbind (Qinhibit_quit
, Qt
);
6409 specbind (Qlast_nonmenu_event
, Qt
); /* Why? --Stef */
6411 /* In case we get recursively called,
6412 and we already saved the match data nonrecursively,
6413 save the same match data in safely recursive fashion. */
6414 if (outer_running_asynch_code
)
6417 tem
= Fmatch_data (Qnil
, Qnil
, Qnil
);
6418 restore_search_regs ();
6419 record_unwind_save_match_data ();
6420 Fset_match_data (tem
, Qt
);
6423 /* For speed, if a search happens within this code,
6424 save the match data in a special nonrecursive fashion. */
6425 running_asynch_code
= 1;
6427 internal_condition_case_1 (read_process_output_call
,
6429 Fcons (proc
, Fcons (reason
, Qnil
))),
6430 !NILP (Vdebug_on_error
) ? Qnil
: Qerror
,
6431 exec_sentinel_error_handler
);
6433 /* If we saved the match data nonrecursively, restore it now. */
6434 restore_search_regs ();
6435 running_asynch_code
= outer_running_asynch_code
;
6437 Vdeactivate_mark
= odeactivate
;
6439 /* Restore waiting_for_user_input_p as it was
6440 when we were called, in case the filter clobbered it. */
6441 waiting_for_user_input_p
= waiting
;
6444 if (! EQ (Fcurrent_buffer (), obuffer
)
6445 || ! EQ (current_buffer
->keymap
, okeymap
))
6447 /* But do it only if the caller is actually going to read events.
6448 Otherwise there's no need to make him wake up, and it could
6449 cause trouble (for example it would make sit_for return). */
6450 if (waiting_for_user_input_p
== -1)
6451 record_asynch_buffer_change ();
6453 unbind_to (count
, Qnil
);
6456 /* Report all recent events of a change in process status
6457 (either run the sentinel or output a message).
6458 This is usually done while Emacs is waiting for keyboard input
6459 but can be done at other times. */
6462 status_notify (struct Lisp_Process
*deleting_process
)
6464 register Lisp_Object proc
, buffer
;
6465 Lisp_Object tail
, msg
;
6466 struct gcpro gcpro1
, gcpro2
;
6470 /* We need to gcpro tail; if read_process_output calls a filter
6471 which deletes a process and removes the cons to which tail points
6472 from Vprocess_alist, and then causes a GC, tail is an unprotected
6476 /* Set this now, so that if new processes are created by sentinels
6477 that we run, we get called again to handle their status changes. */
6478 update_tick
= process_tick
;
6480 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
6483 register struct Lisp_Process
*p
;
6485 proc
= Fcdr (XCAR (tail
));
6486 p
= XPROCESS (proc
);
6488 if (p
->tick
!= p
->update_tick
)
6490 p
->update_tick
= p
->tick
;
6492 /* If process is still active, read any output that remains. */
6493 while (! EQ (p
->filter
, Qt
)
6494 && ! EQ (p
->status
, Qconnect
)
6495 && ! EQ (p
->status
, Qlisten
)
6496 /* Network or serial process not stopped: */
6497 && ! EQ (p
->command
, Qt
)
6499 && p
!= deleting_process
6500 && read_process_output (proc
, p
->infd
) > 0);
6504 /* Get the text to use for the message. */
6505 if (p
->raw_status_new
)
6507 msg
= status_message (p
);
6509 /* If process is terminated, deactivate it or delete it. */
6511 if (CONSP (p
->status
))
6512 symbol
= XCAR (p
->status
);
6514 if (EQ (symbol
, Qsignal
) || EQ (symbol
, Qexit
)
6515 || EQ (symbol
, Qclosed
))
6517 if (delete_exited_processes
)
6518 remove_process (proc
);
6520 deactivate_process (proc
);
6523 /* The actions above may have further incremented p->tick.
6524 So set p->update_tick again
6525 so that an error in the sentinel will not cause
6526 this code to be run again. */
6527 p
->update_tick
= p
->tick
;
6528 /* Now output the message suitably. */
6529 if (!NILP (p
->sentinel
))
6530 exec_sentinel (proc
, msg
);
6531 /* Don't bother with a message in the buffer
6532 when a process becomes runnable. */
6533 else if (!EQ (symbol
, Qrun
) && !NILP (buffer
))
6536 struct buffer
*old
= current_buffer
;
6537 ptrdiff_t opoint
, opoint_byte
;
6538 ptrdiff_t before
, before_byte
;
6540 /* Avoid error if buffer is deleted
6541 (probably that's why the process is dead, too) */
6542 if (NILP (BVAR (XBUFFER (buffer
), name
)))
6544 Fset_buffer (buffer
);
6547 opoint_byte
= PT_BYTE
;
6548 /* Insert new output into buffer
6549 at the current end-of-output marker,
6550 thus preserving logical ordering of input and output. */
6551 if (XMARKER (p
->mark
)->buffer
)
6552 Fgoto_char (p
->mark
);
6554 SET_PT_BOTH (ZV
, ZV_BYTE
);
6557 before_byte
= PT_BYTE
;
6559 tem
= BVAR (current_buffer
, read_only
);
6560 BVAR (current_buffer
, read_only
) = Qnil
;
6561 insert_string ("\nProcess ");
6562 Finsert (1, &p
->name
);
6563 insert_string (" ");
6565 BVAR (current_buffer
, read_only
) = tem
;
6566 set_marker_both (p
->mark
, p
->buffer
, PT
, PT_BYTE
);
6568 if (opoint
>= before
)
6569 SET_PT_BOTH (opoint
+ (PT
- before
),
6570 opoint_byte
+ (PT_BYTE
- before_byte
));
6572 SET_PT_BOTH (opoint
, opoint_byte
);
6574 set_buffer_internal (old
);
6579 update_mode_lines
++; /* in case buffers use %s in mode-line-format */
6584 DEFUN ("set-process-coding-system", Fset_process_coding_system
,
6585 Sset_process_coding_system
, 1, 3, 0,
6586 doc
: /* Set coding systems of PROCESS to DECODING and ENCODING.
6587 DECODING will be used to decode subprocess output and ENCODING to
6588 encode subprocess input. */)
6589 (register Lisp_Object process
, Lisp_Object decoding
, Lisp_Object encoding
)
6591 register struct Lisp_Process
*p
;
6593 CHECK_PROCESS (process
);
6594 p
= XPROCESS (process
);
6596 error ("Input file descriptor of %s closed", SDATA (p
->name
));
6598 error ("Output file descriptor of %s closed", SDATA (p
->name
));
6599 Fcheck_coding_system (decoding
);
6600 Fcheck_coding_system (encoding
);
6601 encoding
= coding_inherit_eol_type (encoding
, Qnil
);
6602 p
->decode_coding_system
= decoding
;
6603 p
->encode_coding_system
= encoding
;
6604 setup_process_coding_systems (process
);
6609 DEFUN ("process-coding-system",
6610 Fprocess_coding_system
, Sprocess_coding_system
, 1, 1, 0,
6611 doc
: /* Return a cons of coding systems for decoding and encoding of PROCESS. */)
6612 (register Lisp_Object process
)
6614 CHECK_PROCESS (process
);
6615 return Fcons (XPROCESS (process
)->decode_coding_system
,
6616 XPROCESS (process
)->encode_coding_system
);
6619 DEFUN ("set-process-filter-multibyte", Fset_process_filter_multibyte
,
6620 Sset_process_filter_multibyte
, 2, 2, 0,
6621 doc
: /* Set multibyteness of the strings given to PROCESS's filter.
6622 If FLAG is non-nil, the filter is given multibyte strings.
6623 If FLAG is nil, the filter is given unibyte strings. In this case,
6624 all character code conversion except for end-of-line conversion is
6626 (Lisp_Object process
, Lisp_Object flag
)
6628 register struct Lisp_Process
*p
;
6630 CHECK_PROCESS (process
);
6631 p
= XPROCESS (process
);
6633 p
->decode_coding_system
= raw_text_coding_system (p
->decode_coding_system
);
6634 setup_process_coding_systems (process
);
6639 DEFUN ("process-filter-multibyte-p", Fprocess_filter_multibyte_p
,
6640 Sprocess_filter_multibyte_p
, 1, 1, 0,
6641 doc
: /* Return t if a multibyte string is given to PROCESS's filter.*/)
6642 (Lisp_Object process
)
6644 register struct Lisp_Process
*p
;
6645 struct coding_system
*coding
;
6647 CHECK_PROCESS (process
);
6648 p
= XPROCESS (process
);
6649 coding
= proc_decode_coding_system
[p
->infd
];
6650 return (CODING_FOR_UNIBYTE (coding
) ? Qnil
: Qt
);
6659 add_gpm_wait_descriptor (int desc
)
6661 add_keyboard_wait_descriptor (desc
);
6665 delete_gpm_wait_descriptor (int desc
)
6667 delete_keyboard_wait_descriptor (desc
);
6674 /* Return nonzero if *MASK has a bit set
6675 that corresponds to one of the keyboard input descriptors. */
6678 keyboard_bit_set (fd_set
*mask
)
6682 for (fd
= 0; fd
<= max_input_desc
; fd
++)
6683 if (FD_ISSET (fd
, mask
) && FD_ISSET (fd
, &input_wait_mask
)
6684 && !FD_ISSET (fd
, &non_keyboard_wait_mask
))
6691 #else /* not subprocesses */
6693 /* Defined on msdos.c. */
6694 extern int sys_select (int, SELECT_TYPE
*, SELECT_TYPE
*, SELECT_TYPE
*,
6697 /* Implementation of wait_reading_process_output, assuming that there
6698 are no subprocesses. Used only by the MS-DOS build.
6700 Wait for timeout to elapse and/or keyboard input to be available.
6703 timeout in seconds, or
6704 zero for no limit, or
6705 -1 means gobble data immediately available but don't wait for any.
6707 read_kbd is a Lisp_Object:
6708 0 to ignore keyboard input, or
6709 1 to return when input is available, or
6710 -1 means caller will actually read the input, so don't throw to
6713 see full version for other parameters. We know that wait_proc will
6714 always be NULL, since `subprocesses' isn't defined.
6716 do_display != 0 means redisplay should be done to show subprocess
6717 output that arrives.
6719 Return true if we received input from any process. */
6722 wait_reading_process_output (int time_limit
, int microsecs
, int read_kbd
,
6724 Lisp_Object wait_for_cell
,
6725 struct Lisp_Process
*wait_proc
, int just_wait_proc
)
6728 EMACS_TIME end_time
, timeout
;
6729 SELECT_TYPE waitchannels
;
6732 /* What does time_limit really mean? */
6733 if (time_limit
|| microsecs
)
6735 EMACS_GET_TIME (end_time
);
6736 EMACS_SET_SECS_USECS (timeout
, time_limit
, microsecs
);
6737 EMACS_ADD_TIME (end_time
, end_time
, timeout
);
6740 /* Turn off periodic alarms (in case they are in use)
6741 and then turn off any other atimers,
6742 because the select emulator uses alarms. */
6744 turn_on_atimers (0);
6748 int timeout_reduced_for_timers
= 0;
6750 /* If calling from keyboard input, do not quit
6751 since we want to return C-g as an input character.
6752 Otherwise, do pending quit if requested. */
6756 /* Exit now if the cell we're waiting for became non-nil. */
6757 if (! NILP (wait_for_cell
) && ! NILP (XCAR (wait_for_cell
)))
6760 /* Compute time from now till when time limit is up */
6761 /* Exit if already run out */
6762 if (time_limit
== -1)
6764 /* -1 specified for timeout means
6765 gobble output available now
6766 but don't wait at all. */
6768 EMACS_SET_SECS_USECS (timeout
, 0, 0);
6770 else if (time_limit
|| microsecs
)
6772 EMACS_GET_TIME (timeout
);
6773 EMACS_SUB_TIME (timeout
, end_time
, timeout
);
6774 if (EMACS_TIME_NEG_P (timeout
))
6779 EMACS_SET_SECS_USECS (timeout
, 100000, 0);
6782 /* If our caller will not immediately handle keyboard events,
6783 run timer events directly.
6784 (Callers that will immediately read keyboard events
6785 call timer_delay on their own.) */
6786 if (NILP (wait_for_cell
))
6788 EMACS_TIME timer_delay
;
6792 int old_timers_run
= timers_run
;
6793 timer_delay
= timer_check ();
6794 if (timers_run
!= old_timers_run
&& do_display
)
6795 /* We must retry, since a timer may have requeued itself
6796 and that could alter the time delay. */
6797 redisplay_preserve_echo_area (14);
6801 while (!detect_input_pending ());
6803 /* If there is unread keyboard input, also return. */
6805 && requeued_events_pending_p ())
6808 if (! EMACS_TIME_NEG_P (timer_delay
) && time_limit
!= -1)
6810 EMACS_TIME difference
;
6811 EMACS_SUB_TIME (difference
, timer_delay
, timeout
);
6812 if (EMACS_TIME_NEG_P (difference
))
6814 timeout
= timer_delay
;
6815 timeout_reduced_for_timers
= 1;
6820 /* Cause C-g and alarm signals to take immediate action,
6821 and cause input available signals to zero out timeout. */
6823 set_waiting_for_input (&timeout
);
6825 /* Wait till there is something to do. */
6827 if (! read_kbd
&& NILP (wait_for_cell
))
6828 FD_ZERO (&waitchannels
);
6830 FD_SET (0, &waitchannels
);
6832 /* If a frame has been newly mapped and needs updating,
6833 reprocess its display stuff. */
6834 if (frame_garbaged
&& do_display
)
6836 clear_waiting_for_input ();
6837 redisplay_preserve_echo_area (15);
6839 set_waiting_for_input (&timeout
);
6842 if (read_kbd
&& detect_input_pending ())
6845 FD_ZERO (&waitchannels
);
6848 nfds
= select (1, &waitchannels
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0,
6853 /* Make C-g and alarm signals set flags again */
6854 clear_waiting_for_input ();
6856 /* If we woke up due to SIGWINCH, actually change size now. */
6857 do_pending_window_change (0);
6859 if (time_limit
&& nfds
== 0 && ! timeout_reduced_for_timers
)
6860 /* We waited the full specified time, so return now. */
6865 /* If the system call was interrupted, then go around the
6867 if (xerrno
== EINTR
)
6868 FD_ZERO (&waitchannels
);
6870 error ("select error: %s", emacs_strerror (xerrno
));
6873 /* Check for keyboard input */
6876 && detect_input_pending_run_timers (do_display
))
6878 swallow_events (do_display
);
6879 if (detect_input_pending_run_timers (do_display
))
6883 /* If there is unread keyboard input, also return. */
6885 && requeued_events_pending_p ())
6888 /* If wait_for_cell. check for keyboard input
6889 but don't run any timers.
6890 ??? (It seems wrong to me to check for keyboard
6891 input at all when wait_for_cell, but the code
6892 has been this way since July 1994.
6893 Try changing this after version 19.31.) */
6894 if (! NILP (wait_for_cell
)
6895 && detect_input_pending ())
6897 swallow_events (do_display
);
6898 if (detect_input_pending ())
6902 /* Exit now if the cell we're waiting for became non-nil. */
6903 if (! NILP (wait_for_cell
) && ! NILP (XCAR (wait_for_cell
)))
6912 #endif /* not subprocesses */
6914 /* The following functions are needed even if async subprocesses are
6915 not supported. Some of them are no-op stubs in that case. */
6917 /* Add DESC to the set of keyboard input descriptors. */
6920 add_keyboard_wait_descriptor (int desc
)
6922 #ifdef subprocesses /* actually means "not MSDOS" */
6923 FD_SET (desc
, &input_wait_mask
);
6924 FD_SET (desc
, &non_process_wait_mask
);
6925 if (desc
> max_input_desc
)
6926 max_input_desc
= desc
;
6930 /* From now on, do not expect DESC to give keyboard input. */
6933 delete_keyboard_wait_descriptor (int desc
)
6937 int lim
= max_input_desc
;
6939 FD_CLR (desc
, &input_wait_mask
);
6940 FD_CLR (desc
, &non_process_wait_mask
);
6942 if (desc
== max_input_desc
)
6943 for (fd
= 0; fd
< lim
; fd
++)
6944 if (FD_ISSET (fd
, &input_wait_mask
) || FD_ISSET (fd
, &write_mask
))
6945 max_input_desc
= fd
;
6949 /* Setup coding systems of PROCESS. */
6952 setup_process_coding_systems (Lisp_Object process
)
6955 struct Lisp_Process
*p
= XPROCESS (process
);
6957 int outch
= p
->outfd
;
6958 Lisp_Object coding_system
;
6960 if (inch
< 0 || outch
< 0)
6963 if (!proc_decode_coding_system
[inch
])
6964 proc_decode_coding_system
[inch
]
6965 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
6966 coding_system
= p
->decode_coding_system
;
6967 if (! NILP (p
->filter
))
6969 else if (BUFFERP (p
->buffer
))
6971 if (NILP (BVAR (XBUFFER (p
->buffer
), enable_multibyte_characters
)))
6972 coding_system
= raw_text_coding_system (coding_system
);
6974 setup_coding_system (coding_system
, proc_decode_coding_system
[inch
]);
6976 if (!proc_encode_coding_system
[outch
])
6977 proc_encode_coding_system
[outch
]
6978 = (struct coding_system
*) xmalloc (sizeof (struct coding_system
));
6979 setup_coding_system (p
->encode_coding_system
,
6980 proc_encode_coding_system
[outch
]);
6984 /* Close all descriptors currently in use for communication
6985 with subprocess. This is used in a newly-forked subprocess
6986 to get rid of irrelevant descriptors. */
6989 close_process_descs (void)
6993 for (i
= 0; i
< MAXDESC
; i
++)
6995 Lisp_Object process
;
6996 process
= chan_process
[i
];
6997 if (!NILP (process
))
6999 int in
= XPROCESS (process
)->infd
;
7000 int out
= XPROCESS (process
)->outfd
;
7003 if (out
>= 0 && in
!= out
)
7010 DEFUN ("get-buffer-process", Fget_buffer_process
, Sget_buffer_process
, 1, 1, 0,
7011 doc
: /* Return the (or a) process associated with BUFFER.
7012 BUFFER may be a buffer or the name of one. */)
7013 (register Lisp_Object buffer
)
7016 register Lisp_Object buf
, tail
, proc
;
7018 if (NILP (buffer
)) return Qnil
;
7019 buf
= Fget_buffer (buffer
);
7020 if (NILP (buf
)) return Qnil
;
7022 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
7024 proc
= Fcdr (XCAR (tail
));
7025 if (PROCESSP (proc
) && EQ (XPROCESS (proc
)->buffer
, buf
))
7028 #endif /* subprocesses */
7032 DEFUN ("process-inherit-coding-system-flag",
7033 Fprocess_inherit_coding_system_flag
, Sprocess_inherit_coding_system_flag
,
7035 doc
: /* Return the value of inherit-coding-system flag for PROCESS.
7036 If this flag is t, `buffer-file-coding-system' of the buffer
7037 associated with PROCESS will inherit the coding system used to decode
7038 the process output. */)
7039 (register Lisp_Object process
)
7042 CHECK_PROCESS (process
);
7043 return XPROCESS (process
)->inherit_coding_system_flag
? Qt
: Qnil
;
7045 /* Ignore the argument and return the value of
7046 inherit-process-coding-system. */
7047 return inherit_process_coding_system
? Qt
: Qnil
;
7051 /* Kill all processes associated with `buffer'.
7052 If `buffer' is nil, kill all processes */
7055 kill_buffer_processes (Lisp_Object buffer
)
7058 Lisp_Object tail
, proc
;
7060 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
7062 proc
= XCDR (XCAR (tail
));
7064 && (NILP (buffer
) || EQ (XPROCESS (proc
)->buffer
, buffer
)))
7066 if (NETCONN_P (proc
) || SERIALCONN_P (proc
))
7067 Fdelete_process (proc
);
7068 else if (XPROCESS (proc
)->infd
>= 0)
7069 process_send_signal (proc
, SIGHUP
, Qnil
, 1);
7072 #else /* subprocesses */
7073 /* Since we have no subprocesses, this does nothing. */
7074 #endif /* subprocesses */
7077 DEFUN ("waiting-for-user-input-p", Fwaiting_for_user_input_p
,
7078 Swaiting_for_user_input_p
, 0, 0, 0,
7079 doc
: /* Returns non-nil if Emacs is waiting for input from the user.
7080 This is intended for use by asynchronous process output filters and sentinels. */)
7084 return (waiting_for_user_input_p
? Qt
: Qnil
);
7090 /* Stop reading input from keyboard sources. */
7093 hold_keyboard_input (void)
7098 /* Resume reading input from keyboard sources. */
7101 unhold_keyboard_input (void)
7106 /* Return non-zero if keyboard input is on hold, zero otherwise. */
7109 kbd_on_hold_p (void)
7111 return kbd_is_on_hold
;
7115 /* Enumeration of and access to system processes a-la ps(1). */
7117 DEFUN ("list-system-processes", Flist_system_processes
, Slist_system_processes
,
7119 doc
: /* Return a list of numerical process IDs of all running processes.
7120 If this functionality is unsupported, return nil.
7122 See `process-attributes' for getting attributes of a process given its ID. */)
7125 return list_system_processes ();
7128 DEFUN ("process-attributes", Fprocess_attributes
,
7129 Sprocess_attributes
, 1, 1, 0,
7130 doc
: /* Return attributes of the process given by its PID, a number.
7132 Value is an alist where each element is a cons cell of the form
7136 If this functionality is unsupported, the value is nil.
7138 See `list-system-processes' for getting a list of all process IDs.
7140 The KEYs of the attributes that this function may return are listed
7141 below, together with the type of the associated VALUE (in parentheses).
7142 Not all platforms support all of these attributes; unsupported
7143 attributes will not appear in the returned alist.
7144 Unless explicitly indicated otherwise, numbers can have either
7145 integer or floating point values.
7147 euid -- Effective user User ID of the process (number)
7148 user -- User name corresponding to euid (string)
7149 egid -- Effective user Group ID of the process (number)
7150 group -- Group name corresponding to egid (string)
7151 comm -- Command name (executable name only) (string)
7152 state -- Process state code, such as "S", "R", or "T" (string)
7153 ppid -- Parent process ID (number)
7154 pgrp -- Process group ID (number)
7155 sess -- Session ID, i.e. process ID of session leader (number)
7156 ttname -- Controlling tty name (string)
7157 tpgid -- ID of foreground process group on the process's tty (number)
7158 minflt -- number of minor page faults (number)
7159 majflt -- number of major page faults (number)
7160 cminflt -- cumulative number of minor page faults (number)
7161 cmajflt -- cumulative number of major page faults (number)
7162 utime -- user time used by the process, in the (HIGH LOW USEC) format
7163 stime -- system time used by the process, in the (HIGH LOW USEC) format
7164 time -- sum of utime and stime, in the (HIGH LOW USEC) format
7165 cutime -- user time used by the process and its children, (HIGH LOW USEC)
7166 cstime -- system time used by the process and its children, (HIGH LOW USEC)
7167 ctime -- sum of cutime and cstime, in the (HIGH LOW USEC) format
7168 pri -- priority of the process (number)
7169 nice -- nice value of the process (number)
7170 thcount -- process thread count (number)
7171 start -- time the process started, in the (HIGH LOW USEC) format
7172 vsize -- virtual memory size of the process in KB's (number)
7173 rss -- resident set size of the process in KB's (number)
7174 etime -- elapsed time the process is running, in (HIGH LOW USEC) format
7175 pcpu -- percents of CPU time used by the process (floating-point number)
7176 pmem -- percents of total physical memory used by process's resident set
7177 (floating-point number)
7178 args -- command line which invoked the process (string). */)
7181 return system_process_attributes (pid
);
7191 inhibit_sentinels
= 0;
7195 if (! noninteractive
|| initialized
)
7197 signal (SIGCHLD
, sigchld_handler
);
7200 FD_ZERO (&input_wait_mask
);
7201 FD_ZERO (&non_keyboard_wait_mask
);
7202 FD_ZERO (&non_process_wait_mask
);
7203 FD_ZERO (&write_mask
);
7204 max_process_desc
= 0;
7205 memset (fd_callback_info
, 0, sizeof (fd_callback_info
));
7207 #ifdef NON_BLOCKING_CONNECT
7208 FD_ZERO (&connect_wait_mask
);
7209 num_pending_connects
= 0;
7212 #ifdef ADAPTIVE_READ_BUFFERING
7213 process_output_delay_count
= 0;
7214 process_output_skip
= 0;
7217 /* Don't do this, it caused infinite select loops. The display
7218 method should call add_keyboard_wait_descriptor on stdin if it
7221 FD_SET (0, &input_wait_mask
);
7224 Vprocess_alist
= Qnil
;
7226 deleted_pid_list
= Qnil
;
7228 for (i
= 0; i
< MAXDESC
; i
++)
7230 chan_process
[i
] = Qnil
;
7231 proc_buffered_char
[i
] = -1;
7233 memset (proc_decode_coding_system
, 0, sizeof proc_decode_coding_system
);
7234 memset (proc_encode_coding_system
, 0, sizeof proc_encode_coding_system
);
7235 #ifdef DATAGRAM_SOCKETS
7236 memset (datagram_address
, 0, sizeof datagram_address
);
7240 Lisp_Object subfeatures
= Qnil
;
7241 const struct socket_options
*sopt
;
7243 #define ADD_SUBFEATURE(key, val) \
7244 subfeatures = pure_cons (pure_cons (key, pure_cons (val, Qnil)), subfeatures)
7246 #ifdef NON_BLOCKING_CONNECT
7247 ADD_SUBFEATURE (QCnowait
, Qt
);
7249 #ifdef DATAGRAM_SOCKETS
7250 ADD_SUBFEATURE (QCtype
, Qdatagram
);
7252 #ifdef HAVE_SEQPACKET
7253 ADD_SUBFEATURE (QCtype
, Qseqpacket
);
7255 #ifdef HAVE_LOCAL_SOCKETS
7256 ADD_SUBFEATURE (QCfamily
, Qlocal
);
7258 ADD_SUBFEATURE (QCfamily
, Qipv4
);
7260 ADD_SUBFEATURE (QCfamily
, Qipv6
);
7262 #ifdef HAVE_GETSOCKNAME
7263 ADD_SUBFEATURE (QCservice
, Qt
);
7265 #if defined (O_NONBLOCK) || defined (O_NDELAY)
7266 ADD_SUBFEATURE (QCserver
, Qt
);
7269 for (sopt
= socket_options
; sopt
->name
; sopt
++)
7270 subfeatures
= pure_cons (intern_c_string (sopt
->name
), subfeatures
);
7272 Fprovide (intern_c_string ("make-network-process"), subfeatures
);
7275 #if defined (DARWIN_OS)
7276 /* PTYs are broken on Darwin < 6, but are sometimes useful for interactive
7277 processes. As such, we only change the default value. */
7280 char const *release
= (STRINGP (Voperating_system_release
)
7281 ? SSDATA (Voperating_system_release
)
7283 if (!release
|| !release
[0] || (release
[0] < MIN_PTY_KERNEL_VERSION
7284 && release
[1] == '.')) {
7285 Vprocess_connection_type
= Qnil
;
7289 #endif /* subprocesses */
7294 syms_of_process (void)
7298 DEFSYM (Qprocessp
, "processp");
7299 DEFSYM (Qrun
, "run");
7300 DEFSYM (Qstop
, "stop");
7301 DEFSYM (Qsignal
, "signal");
7303 /* Qexit is already staticpro'd by syms_of_eval; don't staticpro it
7306 Qexit = intern_c_string ("exit");
7307 staticpro (&Qexit); */
7309 DEFSYM (Qopen
, "open");
7310 DEFSYM (Qclosed
, "closed");
7311 DEFSYM (Qconnect
, "connect");
7312 DEFSYM (Qfailed
, "failed");
7313 DEFSYM (Qlisten
, "listen");
7314 DEFSYM (Qlocal
, "local");
7315 DEFSYM (Qipv4
, "ipv4");
7317 DEFSYM (Qipv6
, "ipv6");
7319 DEFSYM (Qdatagram
, "datagram");
7320 DEFSYM (Qseqpacket
, "seqpacket");
7322 DEFSYM (QCport
, ":port");
7323 DEFSYM (QCspeed
, ":speed");
7324 DEFSYM (QCprocess
, ":process");
7326 DEFSYM (QCbytesize
, ":bytesize");
7327 DEFSYM (QCstopbits
, ":stopbits");
7328 DEFSYM (QCparity
, ":parity");
7329 DEFSYM (Qodd
, "odd");
7330 DEFSYM (Qeven
, "even");
7331 DEFSYM (QCflowcontrol
, ":flowcontrol");
7334 DEFSYM (QCsummary
, ":summary");
7336 DEFSYM (Qreal
, "real");
7337 DEFSYM (Qnetwork
, "network");
7338 DEFSYM (Qserial
, "serial");
7339 DEFSYM (QCbuffer
, ":buffer");
7340 DEFSYM (QChost
, ":host");
7341 DEFSYM (QCservice
, ":service");
7342 DEFSYM (QClocal
, ":local");
7343 DEFSYM (QCremote
, ":remote");
7344 DEFSYM (QCcoding
, ":coding");
7345 DEFSYM (QCserver
, ":server");
7346 DEFSYM (QCnowait
, ":nowait");
7347 DEFSYM (QCsentinel
, ":sentinel");
7348 DEFSYM (QClog
, ":log");
7349 DEFSYM (QCnoquery
, ":noquery");
7350 DEFSYM (QCstop
, ":stop");
7351 DEFSYM (QCoptions
, ":options");
7352 DEFSYM (QCplist
, ":plist");
7354 DEFSYM (Qlast_nonmenu_event
, "last-nonmenu-event");
7356 staticpro (&Vprocess_alist
);
7358 staticpro (&deleted_pid_list
);
7361 #endif /* subprocesses */
7363 DEFSYM (QCname
, ":name");
7364 DEFSYM (QCtype
, ":type");
7366 DEFSYM (Qeuid
, "euid");
7367 DEFSYM (Qegid
, "egid");
7368 DEFSYM (Quser
, "user");
7369 DEFSYM (Qgroup
, "group");
7370 DEFSYM (Qcomm
, "comm");
7371 DEFSYM (Qstate
, "state");
7372 DEFSYM (Qppid
, "ppid");
7373 DEFSYM (Qpgrp
, "pgrp");
7374 DEFSYM (Qsess
, "sess");
7375 DEFSYM (Qttname
, "ttname");
7376 DEFSYM (Qtpgid
, "tpgid");
7377 DEFSYM (Qminflt
, "minflt");
7378 DEFSYM (Qmajflt
, "majflt");
7379 DEFSYM (Qcminflt
, "cminflt");
7380 DEFSYM (Qcmajflt
, "cmajflt");
7381 DEFSYM (Qutime
, "utime");
7382 DEFSYM (Qstime
, "stime");
7383 DEFSYM (Qtime
, "time");
7384 DEFSYM (Qcutime
, "cutime");
7385 DEFSYM (Qcstime
, "cstime");
7386 DEFSYM (Qctime
, "ctime");
7387 DEFSYM (Qpri
, "pri");
7388 DEFSYM (Qnice
, "nice");
7389 DEFSYM (Qthcount
, "thcount");
7390 DEFSYM (Qstart
, "start");
7391 DEFSYM (Qvsize
, "vsize");
7392 DEFSYM (Qrss
, "rss");
7393 DEFSYM (Qetime
, "etime");
7394 DEFSYM (Qpcpu
, "pcpu");
7395 DEFSYM (Qpmem
, "pmem");
7396 DEFSYM (Qargs
, "args");
7398 DEFVAR_BOOL ("delete-exited-processes", delete_exited_processes
,
7399 doc
: /* *Non-nil means delete processes immediately when they exit.
7400 A value of nil means don't delete them until `list-processes' is run. */);
7402 delete_exited_processes
= 1;
7405 DEFVAR_LISP ("process-connection-type", Vprocess_connection_type
,
7406 doc
: /* Control type of device used to communicate with subprocesses.
7407 Values are nil to use a pipe, or t or `pty' to use a pty.
7408 The value has no effect if the system has no ptys or if all ptys are busy:
7409 then a pipe is used in any case.
7410 The value takes effect when `start-process' is called. */);
7411 Vprocess_connection_type
= Qt
;
7413 #ifdef ADAPTIVE_READ_BUFFERING
7414 DEFVAR_LISP ("process-adaptive-read-buffering", Vprocess_adaptive_read_buffering
,
7415 doc
: /* If non-nil, improve receive buffering by delaying after short reads.
7416 On some systems, when Emacs reads the output from a subprocess, the output data
7417 is read in very small blocks, potentially resulting in very poor performance.
7418 This behavior can be remedied to some extent by setting this variable to a
7419 non-nil value, as it will automatically delay reading from such processes, to
7420 allow them to produce more output before Emacs tries to read it.
7421 If the value is t, the delay is reset after each write to the process; any other
7422 non-nil value means that the delay is not reset on write.
7423 The variable takes effect when `start-process' is called. */);
7424 Vprocess_adaptive_read_buffering
= Qt
;
7427 defsubr (&Sprocessp
);
7428 defsubr (&Sget_process
);
7429 defsubr (&Sdelete_process
);
7430 defsubr (&Sprocess_status
);
7431 defsubr (&Sprocess_exit_status
);
7432 defsubr (&Sprocess_id
);
7433 defsubr (&Sprocess_name
);
7434 defsubr (&Sprocess_tty_name
);
7435 defsubr (&Sprocess_command
);
7436 defsubr (&Sset_process_buffer
);
7437 defsubr (&Sprocess_buffer
);
7438 defsubr (&Sprocess_mark
);
7439 defsubr (&Sset_process_filter
);
7440 defsubr (&Sprocess_filter
);
7441 defsubr (&Sset_process_sentinel
);
7442 defsubr (&Sprocess_sentinel
);
7443 defsubr (&Sset_process_window_size
);
7444 defsubr (&Sset_process_inherit_coding_system_flag
);
7445 defsubr (&Sset_process_query_on_exit_flag
);
7446 defsubr (&Sprocess_query_on_exit_flag
);
7447 defsubr (&Sprocess_contact
);
7448 defsubr (&Sprocess_plist
);
7449 defsubr (&Sset_process_plist
);
7450 defsubr (&Sprocess_list
);
7451 defsubr (&Sstart_process
);
7452 defsubr (&Sserial_process_configure
);
7453 defsubr (&Smake_serial_process
);
7454 defsubr (&Sset_network_process_option
);
7455 defsubr (&Smake_network_process
);
7456 defsubr (&Sformat_network_address
);
7457 #if defined (HAVE_NET_IF_H)
7459 defsubr (&Snetwork_interface_list
);
7461 #if defined (SIOCGIFADDR) || defined (SIOCGIFHWADDR) || defined (SIOCGIFFLAGS)
7462 defsubr (&Snetwork_interface_info
);
7464 #endif /* defined (HAVE_NET_IF_H) */
7465 #ifdef DATAGRAM_SOCKETS
7466 defsubr (&Sprocess_datagram_address
);
7467 defsubr (&Sset_process_datagram_address
);
7469 defsubr (&Saccept_process_output
);
7470 defsubr (&Sprocess_send_region
);
7471 defsubr (&Sprocess_send_string
);
7472 defsubr (&Sinterrupt_process
);
7473 defsubr (&Skill_process
);
7474 defsubr (&Squit_process
);
7475 defsubr (&Sstop_process
);
7476 defsubr (&Scontinue_process
);
7477 defsubr (&Sprocess_running_child_p
);
7478 defsubr (&Sprocess_send_eof
);
7479 defsubr (&Ssignal_process
);
7480 defsubr (&Swaiting_for_user_input_p
);
7481 defsubr (&Sprocess_type
);
7482 defsubr (&Sset_process_coding_system
);
7483 defsubr (&Sprocess_coding_system
);
7484 defsubr (&Sset_process_filter_multibyte
);
7485 defsubr (&Sprocess_filter_multibyte_p
);
7487 #endif /* subprocesses */
7489 defsubr (&Sget_buffer_process
);
7490 defsubr (&Sprocess_inherit_coding_system_flag
);
7491 defsubr (&Slist_system_processes
);
7492 defsubr (&Sprocess_attributes
);