HCoop / bpt / emacs.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix a malloc race condition involving strsignal.
[bpt/emacs.git] / src / sysdep.c
CommitLineData
86a5659e 1/* Interfaces to system-dependent kernel and library entries.
acaf905b 2 Copyright (C) 1985-1988, 1993-1995, 1999-2012
8cabe764 3 Free Software Foundation, Inc.
86a5659e
JB		 4
5This file is part of GNU Emacs.
6
9ec0b715 7GNU Emacs is free software: you can redistribute it and/or modify
86a5659e 8it under the terms of the GNU General Public License as published by
9ec0b715
GM		 9the Free Software Foundation, either version 3 of the License, or
10(at your option) any later version.
86a5659e
JB		 11
12GNU Emacs is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
9ec0b715 18along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
86a5659e 19
4838e624 20#include <config.h>
f162bcc3
PE		 21
22#define SYSTIME_INLINE EXTERN_INLINE
23
cf29dd84 24#include <execinfo.h>
5890e9f7 25#include <stdio.h>
06e111a6
DN		 26#ifdef HAVE_PWD_H
27#include <pwd.h>
28#include <grp.h>
29#endif /* HAVE_PWD_H */
06e111a6 30#include <limits.h>
d3eb3bfa 31#include <unistd.h>
53934c98 32
d1fdcab7 33#include <allocator.h>
620f13b0 34#include <c-ctype.h>
d1fdcab7 35#include <careadlinkat.h>
67342916 36#include <ignore-value.h>
d35af63c 37#include <utimens.h>
67342916 38
86a5659e 39#include "lisp.h"
819b8f00 40#include "sysselect.h"
9ac0d9e0 41#include "blockinput.h"
86a5659e 42
7dca65a4
PE		 43#ifdef BSD_SYSTEM
44#include <sys/param.h>
b91b7e4d 45#include <sys/sysctl.h>
7dca65a4
PE		 46#endif
47
48#ifdef __FreeBSD__
b91b7e4d 49#include <sys/user.h>
d054f3fb 50#include <sys/resource.h>
b91b7e4d
EW		 51#include <math.h>
52#endif
53
fe03522b 54#ifdef WINDOWSNT
e15b6288
JR		 55#define read sys_read
56#define write sys_write
62aba0d4
FP		 57#ifndef STDERR_FILENO
58#define STDERR_FILENO fileno(GetStdHandle(STD_ERROR_HANDLE))
59#endif
fe03522b 60#include <windows.h>
fe03522b
RS		 61#endif /* not WINDOWSNT */
62
86a5659e
JB		 63#include <sys/types.h>
64#include <sys/stat.h>
65#include <errno.h>
66
b05af5d3
PE		 67/* Get SI_SRPC_DOMAIN, if it is available. */
68#ifdef HAVE_SYS_SYSTEMINFO_H
69#include <sys/systeminfo.h>
70#endif
71
207bdbdb 72#ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
207bdbdb
RS		 73#include "msdos.h"
74#include <sys/param.h>
15614e61 75#endif
207bdbdb 76
bb4bc8e2 77#include <sys/file.h>
bb4bc8e2 78#include <fcntl.h>
86a5659e 79
e04a4e0d 80#include "systty.h"
94c8642a 81#include "syswait.h"
86a5659e 82
a7ebc409 83#ifdef HAVE_SYS_UTSNAME_H
86a5659e 84#include <sys/utsname.h>
86a5659e 85#include <memory.h>
a7ebc409 86#endif /* HAVE_SYS_UTSNAME_H */
86a5659e 87
e36ec798 88#include "keyboard.h"
0137dbf7 89#include "frame.h"
86a5659e
JB		 90#include "window.h"
91#include "termhooks.h"
92#include "termchar.h"
93#include "termopts.h"
94#include "dispextern.h"
95#include "process.h"
0a125897 96#include "cm.h" /* for reset_sys_modes */
86a5659e 97
fe03522b
RS		 98#ifdef WINDOWSNT
99#include <direct.h>
100/* In process.h which conflicts with the local copy. */
101#define _P_WAIT 0
43db14bb
JB		 102int _cdecl _spawnlp (int, const char *, const char *, ...);
103int _cdecl _getpid (void);
b6682dd9 104extern char *getwd (char *);
fe03522b
RS		 105#endif
106
91bac16a
JB		 107#include "syssignal.h"
108#include "systime.h"
86a5659e 109
1fa53021
PE		 110static int emacs_get_tty (int, struct emacs_tty *);
111static int emacs_set_tty (int, struct emacs_tty *, int);
112
5a16b9bc
PE		 113/* ULLONG_MAX is missing on Red Hat Linux 7.3; see Bug#11781. */
114#ifndef ULLONG_MAX
115#define ULLONG_MAX TYPE_MAXIMUM (unsigned long long int)
116#endif
117
ff2e8052
DN		 118/* Declare here, including term.h is problematic on some systems. */
119extern void tputs (const char *, int, int (*)(int));
120
91433552 121static const int baud_convert[] =
86a5659e
JB		 122 {
123 0, 50, 75, 110, 135, 150, 200, 300, 600, 1200,
124 1800, 2400, 4800, 9600, 19200, 38400
125 };
86a5659e 126
f78f1a83 127
3480d92b 128#if !defined (HAVE_GET_CURRENT_DIR_NAME) || defined (BROKEN_GET_CURRENT_DIR_NAME)
f78f1a83 129
b6682dd9 130/* Return the current working directory. Returns NULL on errors.
f78f1a83
EZ		 131 Any other returned value must be freed with free. This is used
132 only when get_current_dir_name is not defined on the system. */
133char*
cf84bb53 134get_current_dir_name (void)
f78f1a83
EZ		 135{
136 char *buf;
137 char *pwd;
138 struct stat dotstat, pwdstat;
139 /* If PWD is accurate, use it instead of calling getwd. PWD is
140 sometimes a nicer name, and using it may avoid a fatal error if a
141 parent directory is searchable but not readable. */
142 if ((pwd = getenv ("PWD")) != 0
143 && (IS_DIRECTORY_SEP (*pwd) || (*pwd && IS_DEVICE_SEP (pwd[1])))
144 && stat (pwd, &pwdstat) == 0
145 && stat (".", &dotstat) == 0
146 && dotstat.st_ino == pwdstat.st_ino
147 && dotstat.st_dev == pwdstat.st_dev
148#ifdef MAXPATHLEN
149 && strlen (pwd) < MAXPATHLEN
150#endif
151 )
152 {
38182d90 153 buf = malloc (strlen (pwd) + 1);
f78f1a83
EZ		 154 if (!buf)
155 return NULL;
156 strcpy (buf, pwd);
157 }
158#ifdef HAVE_GETCWD
159 else
160 {
161 size_t buf_size = 1024;
38182d90 162 buf = malloc (buf_size);
f78f1a83
EZ		 163 if (!buf)
164 return NULL;
165 for (;;)
166 {
167 if (getcwd (buf, buf_size) == buf)
168 break;
169 if (errno != ERANGE)
170 {
171 int tmp_errno = errno;
172 free (buf);
173 errno = tmp_errno;
174 return NULL;
175 }
176 buf_size *= 2;
38182d90 177 buf = realloc (buf, buf_size);
f78f1a83
EZ		 178 if (!buf)
179 return NULL;
180 }
181 }
182#else
183 else
184 {
185 /* We need MAXPATHLEN here. */
38182d90 186 buf = malloc (MAXPATHLEN + 1);
f78f1a83
EZ		 187 if (!buf)
188 return NULL;
189 if (getwd (buf) == NULL)
190 {
191 int tmp_errno = errno;
192 free (buf);
193 errno = tmp_errno;
194 return NULL;
195 }
196 }
197#endif
198 return buf;
199}
200#endif
201
64e971c3 202\f
9628b887 203/* Discard pending input on all input descriptors. */
91bac16a 204
08633194 205void
971de7fb 206discard_tty_input (void)
86a5659e 207{
fe03522b 208#ifndef WINDOWSNT
91bac16a 209 struct emacs_tty buf;
86a5659e
JB		 210
211 if (noninteractive)
212 return;
213
fe03522b 214#ifdef MSDOS /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
207bdbdb 215 while (dos_keyread () != -1)
fe03522b 216 ;
207bdbdb 217#else /* not MSDOS */
9628b887 218 {
28d7d09f 219 struct tty_display_info *tty;
9628b887
KL		 220 for (tty = tty_list; tty; tty = tty->next)
221 {
0b0d3e0b
KL		 222 if (tty->input) /* Is the device suspended? */
223 {
12e610e8
DN		 224 emacs_get_tty (fileno (tty->input), &buf);
225 emacs_set_tty (fileno (tty->input), &buf, 0);
0b0d3e0b 226 }
9628b887
KL		 227 }
228 }
207bdbdb 229#endif /* not MSDOS */
fe03522b 230#endif /* not WINDOWSNT */
86a5659e
JB		 231}
232
16c290d8 233\f
86a5659e
JB		 234#ifdef SIGTSTP
235
64e971c3 236/* Arrange for character C to be read as the next input from
16c290d8
KL		 237 the terminal.
238 XXX What if we have multiple ttys?
239*/
64e971c3 240
dfcf069d 241void
0c2338d8 242stuff_char (char c)
86a5659e 243{
428a555e 244 if (! FRAME_TERMCAP_P (SELECTED_FRAME ()))
23dab951
RS		 245 return;
246
86a5659e
JB		 247/* Should perhaps error if in batch mode */
248#ifdef TIOCSTI
0b0d3e0b 249 ioctl (fileno (CURTTY()->input), TIOCSTI, &c);
86a5659e 250#else /* no TIOCSTI */
71f06467 251 error ("Cannot stuff terminal input characters in this version of Unix");
86a5659e
JB		 252#endif /* no TIOCSTI */
253}
254
255#endif /* SIGTSTP */
64e971c3 256\f
08633194 257void
16c290d8 258init_baud_rate (int fd)
86a5659e 259{
4c620157 260 int emacs_ospeed;
67342916 261
86a5659e 262 if (noninteractive)
5bdd7bdd 263 emacs_ospeed = 0;
86a5659e
JB		 264 else
265 {
fe03522b 266#ifdef DOS_NT
5bdd7bdd 267 emacs_ospeed = 15;
fe03522b 268#else /* not DOS_NT */
e04a4e0d 269 struct termios sg;
91bac16a 270
71f06467 271 sg.c_cflag = B9600;
16c290d8 272 tcgetattr (fd, &sg);
5bdd7bdd 273 emacs_ospeed = cfgetospeed (&sg);
fe03522b 274#endif /* not DOS_NT */
86a5659e 275 }
177c0ea7 276
5bdd7bdd
GM		 277 baud_rate = (emacs_ospeed < sizeof baud_convert / sizeof baud_convert[0]
278 ? baud_convert[emacs_ospeed] : 9600);
86a5659e
JB		 279 if (baud_rate == 0)
280 baud_rate = 1200;
281}
282
16c290d8 283\f
86a5659e 284
77defa9a 285#ifndef MSDOS
86a5659e 286
e7a6747f 287static void
d311d28c 288wait_for_termination_1 (pid_t pid, int interruptible)
86a5659e
JB		 289{
290 while (1)
291 {
d6dae14b
EZ		 292#ifdef WINDOWSNT
293 wait (0);
294 break;
295#else /* not WINDOWSNT */
4d7e6e51
PE		 296 int status;
297 int wait_result = waitpid (pid, &status, 0);
298 if (wait_result < 0)
9ab714c7 299 {
4d7e6e51
PE		 300 if (errno != EINTR)
301 break;
302 }
303 else
304 {
305 record_child_status_change (wait_result, status);
9ab714c7
RS		 306 break;
307 }
ac3ac859 308
d6dae14b 309#endif /* not WINDOWSNT */
1ef14cb4
LMI		 310 if (interruptible)
311 QUIT;
86a5659e
JB		 312 }
313}
314
e7a6747f
AS		 315/* Wait for subprocess with process id `pid' to terminate and
316 make sure it will get eliminated (not remain forever as a zombie) */
317
318void
d311d28c 319wait_for_termination (pid_t pid)
e7a6747f
AS		 320{
321 wait_for_termination_1 (pid, 0);
322}
323
324/* Like the above, but allow keyboard interruption. */
325void
d311d28c 326interruptible_wait_for_termination (pid_t pid)
e7a6747f
AS		 327{
328 wait_for_termination_1 (pid, 1);
329}
330
86a5659e
JB		 331/*
332 * flush any pending output
333 * (may flush input as well; it does not matter the way we use it)
334 */
177c0ea7 335
08633194 336void
971de7fb 337flush_pending_output (int channel)
86a5659e 338{
9de940b5 339 /* FIXME: maybe this function should be removed */
86a5659e 340}
64e971c3 341\f
86a5659e
JB		 342/* Set up the terminal at the other end of a pseudo-terminal that
343 we will be controlling an inferior through.
344 It should not echo or do line-editing, since that is done
345 in Emacs. No padding needed for insertion into an Emacs buffer. */
346
08633194 347void
971de7fb 348child_setup_tty (int out)
86a5659e 349{
77defa9a 350#ifndef WINDOWSNT
91bac16a
JB		 351 struct emacs_tty s;
352
12e610e8 353 emacs_get_tty (out, &s);
91bac16a
JB		 354 s.main.c_oflag |= OPOST; /* Enable output postprocessing */
355 s.main.c_oflag &= ~ONLCR; /* Disable map of NL to CR-NL on output */
9d4e5eea 356#ifdef NLDLY
07cfc4e7
GM		 357 /* http://lists.gnu.org/archive/html/emacs-devel/2008-05/msg00406.html
358 Some versions of GNU Hurd do not have FFDLY? */
359#ifdef FFDLY
91bac16a
JB		 360 s.main.c_oflag &= ~(NLDLY|CRDLY|TABDLY|BSDLY|VTDLY|FFDLY);
361 /* No output delays */
07cfc4e7
GM		 362#else
363 s.main.c_oflag &= ~(NLDLY|CRDLY|TABDLY|BSDLY|VTDLY);
364 /* No output delays */
365#endif
9d4e5eea 366#endif
91bac16a
JB		 367 s.main.c_lflag &= ~ECHO; /* Disable echo */
368 s.main.c_lflag |= ISIG; /* Enable signals */
9d4e5eea
RS		 369#ifdef IUCLC
370 s.main.c_iflag &= ~IUCLC; /* Disable downcasing on input. */
371#endif
f7097b2a
RS		 372#ifdef ISTRIP
373 s.main.c_iflag &= ~ISTRIP; /* don't strip 8th bit on input */
374#endif
23e4c8be 375#ifdef OLCUC
9d4e5eea
RS		 376 s.main.c_oflag &= ~OLCUC; /* Disable upcasing on output. */
377#endif
f7097b2a 378 s.main.c_oflag &= ~TAB3; /* Disable tab expansion */
1bf96fb5 379 s.main.c_cflag = (s.main.c_cflag & ~CSIZE) | CS8; /* Don't strip 8th bit */
441f6399
RS		 380 s.main.c_cc[VERASE] = CDISABLE; /* disable erase processing */
381 s.main.c_cc[VKILL] = CDISABLE; /* disable kill processing */
91bac16a 382
86a5659e 383#ifdef HPUX
91bac16a 384 s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
86a5659e 385#endif /* HPUX */
91bac16a 386
dfe598b5
RS		 387#ifdef SIGNALS_VIA_CHARACTERS
388 /* the QUIT and INTR character are used in process_send_signal
389 so set them here to something useful. */
fa51fa32 390 if (s.main.c_cc[VQUIT] == CDISABLE)
dfe598b5 391 s.main.c_cc[VQUIT] = '\\'&037; /* Control-\ */
fa51fa32 392 if (s.main.c_cc[VINTR] == CDISABLE)
dfe598b5
RS		 393 s.main.c_cc[VINTR] = 'C'&037; /* Control-C */
394#endif /* not SIGNALS_VIA_CHARACTERS */
395
86a5659e 396#ifdef AIX
86a5659e
JB		 397 /* Also, PTY overloads NUL and BREAK.
398 don't ignore break, but don't signal either, so it looks like NUL. */
91bac16a
JB		 399 s.main.c_iflag &= ~IGNBRK;
400 s.main.c_iflag &= ~BRKINT;
dfe598b5
RS		 401 /* rms: Formerly it set s.main.c_cc[VINTR] to 0377 here
402 unconditionally. Then a SIGNALS_VIA_CHARACTERS conditional
403 would force it to 0377. That looks like duplicated code. */
91bac16a 404 s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
86a5659e
JB		 405#endif /* AIX */
406
aaa0a19a 407 /* We originally enabled ICANON (and set VEOF to 04), and then had
c80e3b4a 408 process.c send additional EOF chars to flush the output when faced
aaa0a19a 409 with long lines, but this leads to weird effects when the
2b0a91e7
SM		 410 subprocess has disabled ICANON and ends up seeing those spurious
411 extra EOFs. So we don't send EOFs any more in
aaa0a19a
SM		 412 process.c:send_process. First we tried to disable ICANON by
413 default, so if a subsprocess sets up ICANON, it's his problem (or
414 the Elisp package that talks to it) to deal with lines that are
415 too long. But this disables some features, such as the ability
416 to send EOF signals. So we re-enabled ICANON but there is no
417 more "send eof to flush" going on (which is wrong and unportable
418 in itself). The correct way to handle too much output is to
419 buffer what could not be written and then write it again when
420 select returns ok for writing. This has it own set of
421 problems. Write is now asynchronous, is that a problem? How much
422 do we buffer, and what do we do when that limit is reached? */
9a747ba6
JD		 423
424 s.main.c_lflag |= ICANON; /* Enable line editing and eof processing */
425 s.main.c_cc[VEOF] = 'D'&037; /* Control-D */
3d15fe78 426#if 0 /* These settings only apply to non-ICANON mode. */
2b0a91e7
SM		 427 s.main.c_cc[VMIN] = 1;
428 s.main.c_cc[VTIME] = 0;
aaa0a19a 429#endif
2b0a91e7 430
12e610e8 431 emacs_set_tty (out, &s, 0);
77defa9a 432#endif /* not WINDOWSNT */
86a5659e 433}
57507bf8 434#endif /* not MSDOS */
86a5659e 435
64e971c3 436\f
2fe28299 437/* Record a signal code and the action for it. */
86a5659e
JB		 438struct save_signal
439{
440 int code;
2fe28299 441 struct sigaction action;
86a5659e
JB		 442};
443
f57e2426
J		 444static void save_signal_handlers (struct save_signal *);
445static void restore_signal_handlers (struct save_signal *);
35a05cca 446
86a5659e
JB		 447/* Suspend the Emacs process; give terminal to its superior. */
448
08633194 449void
971de7fb 450sys_suspend (void)
86a5659e 451{
c4ea52a6 452#if defined (SIGTSTP) && !defined (MSDOS)
86a5659e 453
5a570e37 454 {
e89a2cd5 455 int pgrp = EMACS_GETPGRP (0);
5a570e37
JB		 456 EMACS_KILLPG (pgrp, SIGTSTP);
457 }
86a5659e
JB		 458
459#else /* No SIGTSTP */
86a5659e
JB		 460/* On a system where suspending is not implemented,
461 instead fork a subshell and let it talk directly to the terminal
462 while we wait. */
a0932daa
KH		 463 sys_subshell ();
464
a0932daa 465#endif /* no SIGTSTP */
a0932daa
KH		 466}
467
468/* Fork a subshell. */
469
08633194 470void
971de7fb 471sys_subshell (void)
a0932daa 472{
ad00c243 473#ifdef DOS_NT /* Demacs 1.1.2 91/10/20 Manabu Higashida */
a0932daa
KH		 474 int st;
475 char oldwd[MAXPATHLEN+1]; /* Fixed length is safe on MSDOS. */
476#endif
efa04277 477 int pid;
86a5659e 478 struct save_signal saved_handlers[5];
efa04277 479 Lisp_Object dir;
5e41f65d 480 unsigned char *volatile str_volatile = 0;
7e9123a2 481 unsigned char *str;
efa04277 482 int len;
86a5659e
JB		 483
484 saved_handlers[0].code = SIGINT;
485 saved_handlers[1].code = SIGQUIT;
486 saved_handlers[2].code = SIGTERM;
4a4bbad2 487#ifdef USABLE_SIGIO
86a5659e
JB		 488 saved_handlers[3].code = SIGIO;
489 saved_handlers[4].code = 0;
490#else
491 saved_handlers[3].code = 0;
492#endif
493
efa04277
RS		 494 /* Mentioning current_buffer->buffer would mean including buffer.h,
495 which somehow wedges the hp compiler. So instead... */
496
497 dir = intern ("default-directory");
0e7e7a58 498 if (NILP (Fboundp (dir)))
efa04277
RS		 499 goto xyzzy;
500 dir = Fsymbol_value (dir);
914e81a2 501 if (!STRINGP (dir))
efa04277
RS		 502 goto xyzzy;
503
504 dir = expand_and_dir_to_file (Funhandled_file_name_directory (dir), Qnil);
38182d90 505 str_volatile = str = alloca (SCHARS (dir) + 2);
d5db4077 506 len = SCHARS (dir);
72af86bd 507 memcpy (str, SDATA (dir), len);
efa04277
RS		 508 if (str[len - 1] != '/') str[len++] = '/';
509 str[len] = 0;
510 xyzzy:
511
ad00c243 512#ifdef DOS_NT
7964ba9e 513 pid = 0;
718ca3cf
RS		 514 save_signal_handlers (saved_handlers);
515 synch_process_alive = 1;
177c0ea7 516#else
efa04277 517 pid = vfork ();
86a5659e
JB		 518 if (pid == -1)
519 error ("Can't spawn subshell");
7964ba9e
RS		 520#endif
521
86a5659e
JB		 522 if (pid == 0)
523 {
8ea90aa3 524 const char *sh = 0;
86a5659e 525
ad00c243 526#ifdef DOS_NT /* MW, Aug 1993 */
207bdbdb 527 getwd (oldwd);
7964ba9e
RS		 528 if (sh == 0)
529 sh = (char *) egetenv ("SUSPEND"); /* KFS, 1994-12-14 */
207bdbdb 530#endif
7964ba9e
RS		 531 if (sh == 0)
532 sh = (char *) egetenv ("SHELL");
86a5659e
JB		 533 if (sh == 0)
534 sh = "sh";
207bdbdb 535
86a5659e 536 /* Use our buffer's default directory for the subshell. */
5e41f65d 537 str = str_volatile;
32299e33
PE		 538 if (str && chdir ((char *) str) != 0)
539 {
540#ifndef DOS_NT
541 ignore_value (write (1, "Can't chdir\n", 12));
542 _exit (1);
543#endif
544 }
efa04277 545
86a5659e 546 close_process_descs (); /* Close Emacs's pipes/ptys */
1593c2fe 547
fe03522b 548#ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida */
c0917202 549 {
48178f9a
EZ		 550 char *epwd = getenv ("PWD");
551 char old_pwd[MAXPATHLEN+1+4];
c0917202
EZ		 552
553 /* If PWD is set, pass it with corrected value. */
48178f9a 554 if (epwd)
c0917202 555 {
48178f9a 556 strcpy (old_pwd, epwd);
c0917202
EZ		 557 if (str[len - 1] == '/')
558 str[len - 1] = '\0';
559 setenv ("PWD", str, 1);
560 }
561 st = system (sh);
32299e33 562 chdir (oldwd); /* FIXME: Do the right thing on chdir failure. */
48178f9a 563 if (epwd)
c0917202
EZ		 564 putenv (old_pwd); /* restore previous value */
565 }
207bdbdb 566#else /* not MSDOS */
fe03522b 567#ifdef WINDOWSNT
fe03522b
RS		 568 /* Waits for process completion */
569 pid = _spawnlp (_P_WAIT, sh, sh, NULL);
32299e33 570 chdir (oldwd); /* FIXME: Do the right thing on chdir failure. */
fe03522b
RS		 571 if (pid == -1)
572 write (1, "Can't execute subshell", 22);
fe03522b 573#else /* not WINDOWSNT */
e120ea40 574 execlp (sh, sh, (char *) 0);
67342916 575 ignore_value (write (1, "Can't execute subshell", 22));
86a5659e 576 _exit (1);
fe03522b 577#endif /* not WINDOWSNT */
207bdbdb 578#endif /* not MSDOS */
86a5659e
JB		 579 }
580
718ca3cf 581 /* Do this now if we did not do it before. */
ed68db4d 582#ifndef MSDOS
86a5659e 583 save_signal_handlers (saved_handlers);
ffafc793 584 synch_process_alive = 1;
718ca3cf
RS		 585#endif
586
ad00c243 587#ifndef DOS_NT
86a5659e 588 wait_for_termination (pid);
7964ba9e 589#endif
86a5659e 590 restore_signal_handlers (saved_handlers);
718ca3cf 591 synch_process_alive = 0;
86a5659e
JB		 592}
593
35a05cca 594static void
971de7fb 595save_signal_handlers (struct save_signal *saved_handlers)
86a5659e
JB		 596{
597 while (saved_handlers->code)
598 {
2fe28299
PE		 599 struct sigaction action;
600 emacs_sigaction_init (&action, SIG_IGN);
601 sigaction (saved_handlers->code, &action, &saved_handlers->action);
86a5659e
JB		 602 saved_handlers++;
603 }
604}
605
35a05cca 606static void
971de7fb 607restore_signal_handlers (struct save_signal *saved_handlers)
86a5659e
JB		 608{
609 while (saved_handlers->code)
610 {
2fe28299 611 sigaction (saved_handlers->code, &saved_handlers->action, 0);
86a5659e
JB		 612 saved_handlers++;
613 }
614}
615\f
4a4bbad2 616#ifdef USABLE_SIGIO
1fa53021 617static int old_fcntl_flags[MAXDESC];
4a4bbad2 618#endif
86a5659e 619
08633194 620void
971de7fb 621init_sigio (int fd)
86a5659e 622{
4a4bbad2 623#ifdef USABLE_SIGIO
819b8f00
KL		 624 old_fcntl_flags[fd] = fcntl (fd, F_GETFL, 0) & ~FASYNC;
625 fcntl (fd, F_SETFL, old_fcntl_flags[fd] | FASYNC);
23dab951 626 interrupts_deferred = 0;
4a4bbad2 627#endif
86a5659e
JB		 628}
629
604efe86 630static void
971de7fb 631reset_sigio (int fd)
86a5659e 632{
4a4bbad2 633#ifdef USABLE_SIGIO
819b8f00 634 fcntl (fd, F_SETFL, old_fcntl_flags[fd]);
4d553a13 635#endif
86a5659e
JB		 636}
637
08633194 638void
971de7fb 639request_sigio (void)
86a5659e 640{
4a4bbad2 641#ifdef USABLE_SIGIO
2fe28299
PE		 642 sigset_t unblocked;
643
6bbba5a6 644 if (noninteractive)
23dab951
RS		 645 return;
646
2fe28299 647 sigemptyset (&unblocked);
4a4bbad2 648# ifdef SIGWINCH
2fe28299 649 sigaddset (&unblocked, SIGWINCH);
4a4bbad2 650# endif
2fe28299
PE		 651 sigaddset (&unblocked, SIGIO);
652 pthread_sigmask (SIG_UNBLOCK, &unblocked, 0);
86a5659e
JB		 653
654 interrupts_deferred = 0;
4a4bbad2 655#endif
86a5659e
JB		 656}
657
08633194 658void
0a125897 659unrequest_sigio (void)
cf84bb53 660{
4a4bbad2 661#ifdef USABLE_SIGIO
2fe28299
PE		 662 sigset_t blocked;
663
6bbba5a6
KL		 664 if (noninteractive)
665 return;
666
2fe28299 667 sigemptyset (&blocked);
4a4bbad2 668# ifdef SIGWINCH
2fe28299 669 sigaddset (&blocked, SIGWINCH);
4a4bbad2 670# endif
2fe28299
PE		 671 sigaddset (&blocked, SIGIO);
672 pthread_sigmask (SIG_BLOCK, &blocked, 0);
86a5659e 673 interrupts_deferred = 1;
4a4bbad2 674#endif
86a5659e 675}
177c0ea7 676
08633194 677void
4a4bbad2 678ignore_sigio (void)
86a5659e 679{
4a4bbad2
PE		 680#ifdef USABLE_SIGIO
681 signal (SIGIO, SIG_IGN);
682#endif
86a5659e 683}
feb67dfe 684
9ae8f997 685\f
68936329
JB		 686/* Getting and setting emacs_tty structures. */
687
688/* Set *TC to the parameters associated with the terminal FD.
689 Return zero if all's well, or -1 if we ran into an error we
690 couldn't deal with. */
691int
971de7fb 692emacs_get_tty (int fd, struct emacs_tty *settings)
68936329
JB		 693{
694 /* Retrieve the primary parameters - baud rate, character size, etcetera. */
a7ebc409 695#ifndef DOS_NT
68936329 696 /* We have those nifty POSIX tcmumbleattr functions. */
72af86bd 697 memset (&settings->main, 0, sizeof (settings->main));
68936329
JB		 698 if (tcgetattr (fd, &settings->main) < 0)
699 return -1;
68936329
JB		 700#endif
701
702 /* We have survived the tempest. */
703 return 0;
704}
705
706
707/* Set the parameters of the tty on FD according to the contents of
394049ec 708 *SETTINGS. If FLUSHP is non-zero, we discard input.
68936329 709 Return 0 if all went well, and -1 if anything failed. */
394049ec 710
68936329 711int
971de7fb 712emacs_set_tty (int fd, struct emacs_tty *settings, int flushp)
68936329
JB		 713{
714 /* Set the primary parameters - baud rate, character size, etcetera. */
a7ebc409 715#ifndef DOS_NT
e6cc3307 716 int i;
68936329
JB		 717 /* We have those nifty POSIX tcmumbleattr functions.
718 William J. Smith <wjs@wiis.wang.com> writes:
c4ea52a6 719 "POSIX 1003.1 defines tcsetattr to return success if it was
68936329
JB		 720 able to perform any of the requested actions, even if some
721 of the requested actions could not be performed.
722 We must read settings back to ensure tty setup properly.
723 AIX requires this to keep tty from hanging occasionally." */
eb8c3be9 724 /* This make sure that we don't loop indefinitely in here. */
e6cc3307 725 for (i = 0 ; i < 10 ; i++)
394049ec 726 if (tcsetattr (fd, flushp ? TCSAFLUSH : TCSADRAIN, &settings->main) < 0)
68936329
JB		 727 {
728 if (errno == EINTR)
729 continue;
730 else
731 return -1;
732 }
733 else
734 {
735 struct termios new;
736
72af86bd 737 memset (&new, 0, sizeof (new));
68936329
JB		 738 /* Get the current settings, and see if they're what we asked for. */
739 tcgetattr (fd, &new);
e6cc3307
RS		 740 /* We cannot use memcmp on the whole structure here because under
741 * aix386 the termios structure has some reserved field that may
742 * not be filled in.
743 */
744 if ( new.c_iflag == settings->main.c_iflag
745 && new.c_oflag == settings->main.c_oflag
746 && new.c_cflag == settings->main.c_cflag
747 && new.c_lflag == settings->main.c_lflag
c4ea52a6 748 && memcmp (new.c_cc, settings->main.c_cc, NCCS) == 0)
68936329 749 break;
e6cc3307
RS		 750 else
751 continue;
68936329 752 }
68936329 753#endif
177c0ea7 754
68936329
JB		 755 /* We have survived the tempest. */
756 return 0;
757}
758
759\f
86a5659e
JB		 760
761#ifdef F_SETOWN
1fa53021 762static int old_fcntl_owner[MAXDESC];
86a5659e
JB		 763#endif /* F_SETOWN */
764
86a5659e
JB		 765/* This may also be defined in stdio,
766 but if so, this does no harm,
767 and using the same name avoids wasting the other one's space. */
768
9d9a7716 769#if defined (USG)
86a5659e
JB		 770unsigned char _sobuf[BUFSIZ+8];
771#else
772char _sobuf[BUFSIZ];
773#endif
177c0ea7 774
da8e1115
KL		 775/* Initialize the terminal mode on all tty devices that are currently
776 open. */
777
08633194 778void
28d440ab
KL		 779init_all_sys_modes (void)
780{
28d7d09f 781 struct tty_display_info *tty;
16c290d8 782 for (tty = tty_list; tty; tty = tty->next)
28d440ab 783 init_sys_modes (tty);
28d440ab
KL		 784}
785
da8e1115
KL		 786/* Initialize the terminal mode on the given tty device. */
787
28d440ab 788void
971de7fb 789init_sys_modes (struct tty_display_info *tty_out)
86a5659e 790{
91bac16a 791 struct emacs_tty tty;
e112cc37 792 Lisp_Object terminal;
91bac16a 793
4ec5cb58
RS		 794 Vtty_erase_char = Qnil;
795
86a5659e
JB		 796 if (noninteractive)
797 return;
798
0b0d3e0b
KL		 799 if (!tty_out->output)
800 return; /* The tty is suspended. */
cf84bb53 801
2246281f 802 if (! tty_out->old_tty)
38182d90 803 tty_out->old_tty = xmalloc (sizeof *tty_out->old_tty);
cf84bb53 804
12e610e8 805 emacs_get_tty (fileno (tty_out->input), tty_out->old_tty);
23dab951 806
2246281f 807 tty = *tty_out->old_tty;
86a5659e 808
a7ebc409 809#if !defined (DOS_NT)
2246281f 810 XSETINT (Vtty_erase_char, tty.main.c_cc[VERASE]);
4ec5cb58 811
2246281f
KL		 812 tty.main.c_iflag |= (IGNBRK); /* Ignore break condition */
813 tty.main.c_iflag &= ~ICRNL; /* Disable map of CR to NL on input */
7f371164
RS		 814#ifdef INLCR /* I'm just being cautious,
815 since I can't check how widespread INLCR is--rms. */
2246281f 816 tty.main.c_iflag &= ~INLCR; /* Disable map of NL to CR on input */
7f371164 817#endif
86a5659e 818#ifdef ISTRIP
2246281f 819 tty.main.c_iflag &= ~ISTRIP; /* don't strip 8th bit on input */
86a5659e 820#endif
2246281f
KL		 821 tty.main.c_lflag &= ~ECHO; /* Disable echo */
822 tty.main.c_lflag &= ~ICANON; /* Disable erase/kill processing */
e2b40c23 823#ifdef IEXTEN
2246281f 824 tty.main.c_lflag &= ~IEXTEN; /* Disable other editing characters. */
e2b40c23 825#endif
2246281f
KL		 826 tty.main.c_lflag |= ISIG; /* Enable signals */
827 if (tty_out->flow_control)
828 {
829 tty.main.c_iflag |= IXON; /* Enable start/stop output control */
86a5659e 830#ifdef IXANY
2246281f 831 tty.main.c_iflag &= ~IXANY;
86a5659e 832#endif /* IXANY */
2246281f
KL		 833 }
834 else
835 tty.main.c_iflag &= ~IXON; /* Disable start/stop output control */
836 tty.main.c_oflag &= ~ONLCR; /* Disable map of NL to CR-NL
837 on output */
838 tty.main.c_oflag &= ~TAB3; /* Disable tab expansion */
86a5659e 839#ifdef CS8
2246281f
KL		 840 if (tty_out->meta_key)
841 {
842 tty.main.c_cflag |= CS8; /* allow 8th bit on input */
843 tty.main.c_cflag &= ~PARENB;/* Don't check parity */
844 }
86a5659e 845#endif
e112cc37
ET		 846
847 XSETTERMINAL(terminal, tty_out->terminal);
848 if (!NILP (Fcontrolling_tty_p (terminal)))
2246281f
KL		 849 {
850 tty.main.c_cc[VINTR] = quit_char; /* C-g (usually) gives SIGINT */
851 /* Set up C-g for both SIGQUIT and SIGINT.
852 We don't know which we will get, but we handle both alike
853 so which one it really gives us does not matter. */
854 tty.main.c_cc[VQUIT] = quit_char;
855 }
856 else
857 {
858 /* We normally don't get interrupt or quit signals from tty
859 devices other than our controlling terminal; therefore,
860 we must handle C-g as normal input. Unfortunately, this
861 means that the interrupt and quit feature must be
862 disabled on secondary ttys, or we would not even see the
863 keypress.
cf84bb53 864
2246281f
KL		 865 Note that even though emacsclient could have special code
866 to pass SIGINT to Emacs, we should _not_ enable
867 interrupt/quit keys for emacsclient frames. This means
868 that we can't break out of loops in C code from a
869 secondary tty frame, but we can always decide what
870 display the C-g came from, which is more important from a
871 usability point of view. (Consider the case when two
872 people work together using the same Emacs instance.) */
873 tty.main.c_cc[VINTR] = CDISABLE;
874 tty.main.c_cc[VQUIT] = CDISABLE;
875 }
876 tty.main.c_cc[VMIN] = 1; /* Input should wait for at least 1 char */
877 tty.main.c_cc[VTIME] = 0; /* no matter how long that takes. */
86a5659e 878#ifdef VSWTCH
2246281f 879 tty.main.c_cc[VSWTCH] = CDISABLE; /* Turn off shell layering use
91bac16a 880 of C-z */
86a5659e 881#endif /* VSWTCH */
cf84bb53 882
86a5659e 883#ifdef VSUSP
a7ebc409 884 tty.main.c_cc[VSUSP] = CDISABLE; /* Turn off handling of C-z. */
86a5659e
JB		 885#endif /* VSUSP */
886#ifdef V_DSUSP
a7ebc409 887 tty.main.c_cc[V_DSUSP] = CDISABLE; /* Turn off handling of C-y. */
86a5659e 888#endif /* V_DSUSP */
e2b40c23 889#ifdef VDSUSP /* Some systems have VDSUSP, some have V_DSUSP. */
2246281f 890 tty.main.c_cc[VDSUSP] = CDISABLE;
e2b40c23 891#endif /* VDSUSP */
92c995de 892#ifdef VLNEXT
2246281f 893 tty.main.c_cc[VLNEXT] = CDISABLE;
92c995de
RS		 894#endif /* VLNEXT */
895#ifdef VREPRINT
2246281f 896 tty.main.c_cc[VREPRINT] = CDISABLE;
92c995de
RS		 897#endif /* VREPRINT */
898#ifdef VWERASE
2246281f 899 tty.main.c_cc[VWERASE] = CDISABLE;
92c995de
RS		 900#endif /* VWERASE */
901#ifdef VDISCARD
2246281f 902 tty.main.c_cc[VDISCARD] = CDISABLE;
92c995de 903#endif /* VDISCARD */
c179a6d1 904
2246281f
KL		 905 if (tty_out->flow_control)
906 {
421dd92f 907#ifdef VSTART
2246281f 908 tty.main.c_cc[VSTART] = '\021';
421dd92f
RS		 909#endif /* VSTART */
910#ifdef VSTOP
2246281f 911 tty.main.c_cc[VSTOP] = '\023';
421dd92f 912#endif /* VSTOP */
2246281f
KL		 913 }
914 else
915 {
c179a6d1 916#ifdef VSTART
2246281f 917 tty.main.c_cc[VSTART] = CDISABLE;
c179a6d1
RS		 918#endif /* VSTART */
919#ifdef VSTOP
2246281f 920 tty.main.c_cc[VSTOP] = CDISABLE;
c179a6d1 921#endif /* VSTOP */
2246281f 922 }
c179a6d1 923
86a5659e 924#ifdef AIX
f5272227
KL		 925 tty.main.c_cc[VSTRT] = CDISABLE;
926 tty.main.c_cc[VSTOP] = CDISABLE;
927 tty.main.c_cc[VSUSP] = CDISABLE;
928 tty.main.c_cc[VDSUSP] = CDISABLE;
2246281f
KL		 929 if (tty_out->flow_control)
930 {
ac567c95 931#ifdef VSTART
2246281f 932 tty.main.c_cc[VSTART] = '\021';
ac567c95
RS		 933#endif /* VSTART */
934#ifdef VSTOP
2246281f 935 tty.main.c_cc[VSTOP] = '\023';
ac567c95 936#endif /* VSTOP */
2246281f
KL		 937 }
938 /* Also, PTY overloads NUL and BREAK.
939 don't ignore break, but don't signal either, so it looks like NUL.
940 This really serves a purpose only if running in an XTERM window
941 or via TELNET or the like, but does no harm elsewhere. */
942 tty.main.c_iflag &= ~IGNBRK;
943 tty.main.c_iflag &= ~BRKINT;
86a5659e 944#endif
fe03522b 945#endif /* not DOS_NT */
cf84bb53 946
207bdbdb 947#ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
2246281f
KL		 948 if (!tty_out->term_initted)
949 internal_terminal_init ();
4e389d32 950 dos_ttraw (tty_out);
207bdbdb 951#endif
91bac16a 952
12e610e8 953 emacs_set_tty (fileno (tty_out->input), &tty, 0);
86a5659e 954
2246281f
KL		 955 /* This code added to insure that, if flow-control is not to be used,
956 we have an unlocked terminal at the start. */
91bac16a 957
86a5659e 958#ifdef TCXONC
0b0d3e0b 959 if (!tty_out->flow_control) ioctl (fileno (tty_out->input), TCXONC, 1);
86a5659e 960#endif
86a5659e 961#ifdef TIOCSTART
0b0d3e0b 962 if (!tty_out->flow_control) ioctl (fileno (tty_out->input), TIOCSTART, 0);
86a5659e 963#endif
86a5659e 964
a7ebc409 965#if !defined (DOS_NT)
51417996 966#ifdef TCOON
0b0d3e0b 967 if (!tty_out->flow_control) tcflow (fileno (tty_out->input), TCOON);
d228f207 968#endif
51417996 969#endif
d228f207 970
86a5659e 971#ifdef F_SETFL
eb8c3be9 972#ifdef F_GETOWN /* F_SETFL does not imply existence of F_GETOWN */
2246281f 973 if (interrupt_input)
86a5659e 974 {
0b0d3e0b
KL		 975 old_fcntl_owner[fileno (tty_out->input)] =
976 fcntl (fileno (tty_out->input), F_GETOWN, 0);
977 fcntl (fileno (tty_out->input), F_SETOWN, getpid ());
978 init_sigio (fileno (tty_out->input));
7e5a23bd 979#ifdef HAVE_GPM
75a8734b 980 if (gpm_tty == tty_out)
3e748bcb 981 {
75a8734b 982 /* Arrange for mouse events to give us SIGIO signals. */
3e748bcb 983 fcntl (gpm_fd, F_SETOWN, getpid ());
57669cf1 984 fcntl (gpm_fd, F_SETFL, fcntl (gpm_fd, F_GETFL, 0) | O_NONBLOCK);
3e748bcb
NR		 985 init_sigio (gpm_fd);
986 }
7e5a23bd 987#endif /* HAVE_GPM */
86a5659e
JB		 988 }
989#endif /* F_GETOWN */
990#endif /* F_SETFL */
991
86a5659e
JB		 992#ifdef _IOFBF
993 /* This symbol is defined on recent USG systems.
994 Someone says without this call USG won't really buffer the file
995 even with a call to setbuf. */
0b0d3e0b 996 setvbuf (tty_out->output, (char *) _sobuf, _IOFBF, sizeof _sobuf);
86a5659e 997#else
0b0d3e0b 998 setbuf (tty_out->output, (char *) _sobuf);
86a5659e 999#endif
4d553a13 1000
69fb5031
JR		 1001 if (tty_out->terminal->set_terminal_modes_hook)
1002 tty_out->terminal->set_terminal_modes_hook (tty_out->terminal);
4b311aaf 1003
9628b887
KL		 1004 if (!tty_out->term_initted)
1005 {
1006 Lisp_Object tail, frame;
1007 FOR_EACH_FRAME (tail, frame)
1008 {
daf01701 1009 /* XXX This needs to be revised. */
9628b887
KL		 1010 if (FRAME_TERMCAP_P (XFRAME (frame))
1011 && FRAME_TTY (XFRAME (frame)) == tty_out)
1012 init_frame_faces (XFRAME (frame));
1013 }
1014 }
045942b2 1015
9628b887 1016 if (tty_out->term_initted && no_redraw_on_reenter)
86a5659e 1017 {
855a0da7
SM		 1018 /* We used to call "direct_output_forward_char(0)" here,
1019 but it's not clear why, since it may not do anything anyway. */
86a5659e
JB		 1020 }
1021 else
1022 {
9628b887 1023 Lisp_Object tail, frame;
0137dbf7 1024 frame_garbaged = 1;
9628b887
KL		 1025 FOR_EACH_FRAME (tail, frame)
1026 {
7ab98847
EZ		 1027 if ((FRAME_TERMCAP_P (XFRAME (frame))
1028 || FRAME_MSDOS_P (XFRAME (frame)))
9628b887
KL		 1029 && FRAME_TTY (XFRAME (frame)) == tty_out)
1030 FRAME_GARBAGED_P (XFRAME (frame)) = 1;
1031 }
86a5659e 1032 }
91bac16a 1033
9628b887 1034 tty_out->term_initted = 1;
86a5659e
JB		 1035}
1036
1037/* Return nonzero if safe to use tabs in output.
1038 At the time this is called, init_sys_modes has not been done yet. */
177c0ea7 1039
dfcf069d 1040int
16c290d8 1041tabs_safe_p (int fd)
86a5659e 1042{
6548cf00 1043 struct emacs_tty etty;
91bac16a 1044
12e610e8
DN		 1045 emacs_get_tty (fd, &etty);
1046#ifndef DOS_NT
1047#ifdef TABDLY
1048 return ((etty.main.c_oflag & TABDLY) != TAB3);
1049#else /* not TABDLY */
1050 return 1;
1051#endif /* not TABDLY */
1052#else /* DOS_NT */
1053 return 0;
1054#endif /* DOS_NT */
86a5659e 1055}
73d5358f 1056\f
86a5659e 1057/* Get terminal size from system.
73d5358f
RS		 1058 Store number of lines into *HEIGHTP and width into *WIDTHP.
1059 We store 0 if there's no valid information. */
86a5659e 1060
08633194 1061void
16c290d8 1062get_tty_size (int fd, int *widthp, int *heightp)
86a5659e 1063{
e16e55d4 1064#if defined TIOCGWINSZ
91bac16a
JB		 1065
1066 /* BSD-style. */
86a5659e 1067 struct winsize size;
91bac16a 1068
16c290d8 1069 if (ioctl (fd, TIOCGWINSZ, &size) == -1)
91bac16a
JB		 1070 *widthp = *heightp = 0;
1071 else
1072 {
1073 *widthp = size.ws_col;
1074 *heightp = size.ws_row;
1075 }
1076
e16e55d4 1077#elif defined TIOCGSIZE
91bac16a
JB		 1078
1079 /* SunOS - style. */
177c0ea7 1080 struct ttysize size;
91bac16a 1081
16c290d8 1082 if (ioctl (fd, TIOCGSIZE, &size) == -1)
91bac16a
JB		 1083 *widthp = *heightp = 0;
1084 else
1085 {
1086 *widthp = size.ts_cols;
1087 *heightp = size.ts_lines;
1088 }
1089
e16e55d4
JB		 1090#elif defined WINDOWSNT
1091
1092 CONSOLE_SCREEN_BUFFER_INFO info;
1093 if (GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &info))
1094 {
1095 *widthp = info.srWindow.Right - info.srWindow.Left + 1;
1096 *heightp = info.srWindow.Bottom - info.srWindow.Top + 1;
1097 }
1098 else
1099 *widthp = *heightp = 0;
1100
1101#elif defined MSDOS
1102
207bdbdb
RS		 1103 *widthp = ScreenCols ();
1104 *heightp = ScreenRows ();
e16e55d4 1105
86a5659e 1106#else /* system doesn't know size */
e16e55d4 1107
86a5659e
JB		 1108 *widthp = 0;
1109 *heightp = 0;
e16e55d4 1110
207bdbdb 1111#endif
86a5659e 1112}
91bac16a 1113
73d5358f
RS		 1114/* Set the logical window size associated with descriptor FD
1115 to HEIGHT and WIDTH. This is used mainly with ptys. */
1116
1117int
971de7fb 1118set_window_size (int fd, int height, int width)
73d5358f
RS		 1119{
1120#ifdef TIOCSWINSZ
1121
1122 /* BSD-style. */
1123 struct winsize size;
1124 size.ws_row = height;
1125 size.ws_col = width;
1126
1127 if (ioctl (fd, TIOCSWINSZ, &size) == -1)
1128 return 0; /* error */
1129 else
1130 return 1;
1131
1132#else
1133#ifdef TIOCSSIZE
1134
1135 /* SunOS - style. */
177c0ea7 1136 struct ttysize size;
73d5358f
RS		 1137 size.ts_lines = height;
1138 size.ts_cols = width;
1139
1140 if (ioctl (fd, TIOCGSIZE, &size) == -1)
1141 return 0;
1142 else
1143 return 1;
1144#else
1145 return -1;
1146#endif /* not SunOS-style */
1147#endif /* not BSD-style */
1148}
1149
86a5659e 1150\f
da8e1115
KL		 1151
1152/* Prepare all terminal devices for exiting Emacs. */
1153
28d440ab
KL		 1154void
1155reset_all_sys_modes (void)
1156{
28d7d09f 1157 struct tty_display_info *tty;
16c290d8 1158 for (tty = tty_list; tty; tty = tty->next)
28d440ab 1159 reset_sys_modes (tty);
28d440ab
KL		 1160}
1161
0a125897 1162/* Prepare the terminal for closing it; move the cursor to the
0137dbf7 1163 bottom of the frame, turn off interrupt-driven I/O, etc. */
da8e1115 1164
08633194 1165void
971de7fb 1166reset_sys_modes (struct tty_display_info *tty_out)
86a5659e
JB		 1167{
1168 if (noninteractive)
1169 {
1170 fflush (stdout);
1171 return;
1172 }
9628b887 1173 if (!tty_out->term_initted)
86a5659e 1174 return;
da8e1115 1175
0b0d3e0b
KL		 1176 if (!tty_out->output)
1177 return; /* The tty is suspended. */
cf84bb53 1178
da8e1115
KL		 1179 /* Go to and clear the last line of the terminal. */
1180
0a125897 1181 cmgoto (tty_out, FrameRows (tty_out) - 1, 0);
cf84bb53 1182
da8e1115
KL		 1183 /* Code adapted from tty_clear_end_of_line. */
1184 if (tty_out->TS_clr_line)
1185 {
1186 emacs_tputs (tty_out, tty_out->TS_clr_line, 1, cmputc);
1187 }
1188 else
1189 { /* have to do it the hard way */
1190 int i;
ed8dad6b 1191 tty_turn_off_insert (tty_out);
cf84bb53 1192
da8e1115 1193 for (i = curX (tty_out); i < FrameCols (tty_out) - 1; i++)
0b0d3e0b
KL		 1194 {
1195 fputc (' ', tty_out->output);
1196 }
da8e1115 1197 }
cf84bb53 1198
0a125897 1199 cmgoto (tty_out, FrameRows (tty_out) - 1, 0);
819b8f00 1200 fflush (tty_out->output);
cf84bb53 1201
69fb5031
JR		 1202 if (tty_out->terminal->reset_terminal_modes_hook)
1203 tty_out->terminal->reset_terminal_modes_hook (tty_out->terminal);
2f98e6e3 1204
2a633456 1205#ifdef BSD_SYSTEM
86a5659e 1206 /* Avoid possible loss of output when changing terminal modes. */
0b0d3e0b 1207 fsync (fileno (tty_out->output));
86a5659e 1208#endif
91bac16a 1209
86a5659e 1210#ifdef F_SETFL
eb8c3be9 1211#ifdef F_SETOWN /* F_SETFL does not imply existence of F_SETOWN */
86a5659e
JB		 1212 if (interrupt_input)
1213 {
0b0d3e0b
KL		 1214 reset_sigio (fileno (tty_out->input));
1215 fcntl (fileno (tty_out->input), F_SETOWN,
1216 old_fcntl_owner[fileno (tty_out->input)]);
86a5659e
JB		 1217 }
1218#endif /* F_SETOWN */
a6b00318 1219#ifdef O_NDELAY
0b0d3e0b
KL		 1220 fcntl (fileno (tty_out->input), F_SETFL,
1221 fcntl (fileno (tty_out->input), F_GETFL, 0) & ~O_NDELAY);
a6b00318 1222#endif
86a5659e 1223#endif /* F_SETFL */
91bac16a 1224
fca177d4 1225 if (tty_out->old_tty)
12e610e8 1226 while (emacs_set_tty (fileno (tty_out->input),
fca177d4 1227 tty_out->old_tty, 0) < 0 && errno == EINTR)
7e32a4fb 1228 ;
86a5659e 1229
207bdbdb
RS		 1230#ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida */
1231 dos_ttcooked ();
1232#endif
1233
86a5659e
JB		 1234}
1235\f
1236#ifdef HAVE_PTYS
1237
1238/* Set up the proper status flags for use of a pty. */
1239
08633194 1240void
971de7fb 1241setup_pty (int fd)
86a5659e
JB		 1242{
1243 /* I'm told that TOICREMOTE does not mean control chars
1244 "can't be sent" but rather that they don't have
1245 input-editing or signaling effects.
1246 That should be good, because we have other ways
1247 to do those things in Emacs.
1248 However, telnet mode seems not to work on 4.2.
1249 So TIOCREMOTE is turned off now. */
1250
1251 /* Under hp-ux, if TIOCREMOTE is turned on, some calls
1252 will hang. In particular, the "timeout" feature (which
1253 causes a read to return if there is no data available)
1254 does this. Also it is known that telnet mode will hang
1255 in such a way that Emacs must be stopped (perhaps this
1256 is the same problem).
177c0ea7 1257
86a5659e
JB		 1258 If TIOCREMOTE is turned off, then there is a bug in
1259 hp-ux which sometimes loses data. Apparently the
1260 code which blocks the master process when the internal
1261 buffer fills up does not work. Other than this,
1262 though, everything else seems to work fine.
177c0ea7 1263
86a5659e
JB		 1264 Since the latter lossage is more benign, we may as well
1265 lose that way. -- cph */
1266#ifdef FIONBIO
5e617bc2 1267#if defined (UNIX98_PTYS)
86a5659e
JB		 1268 {
1269 int on = 1;
1270 ioctl (fd, FIONBIO, &on);
1271 }
1272#endif
1273#endif
86a5659e
JB		 1274}
1275#endif /* HAVE_PTYS */
1276\f
f8a80313
RS		 1277#ifdef HAVE_SOCKETS
1278#include <sys/socket.h>
1279#include <netdb.h>
1280#endif /* HAVE_SOCKETS */
f8a80313 1281
8581cd64
KH		 1282#ifdef TRY_AGAIN
1283#ifndef HAVE_H_ERRNO
1284extern int h_errno;
1285#endif
1286#endif /* TRY_AGAIN */
1287
c0c86835 1288void
971de7fb 1289init_system_name (void)
86a5659e 1290{
210b2b4f 1291#ifndef HAVE_GETHOSTNAME
c0c86835
KH		 1292 struct utsname uts;
1293 uname (&uts);
1294 Vsystem_name = build_string (uts.nodename);
67004ffb 1295#else /* HAVE_GETHOSTNAME */
cc6e7269 1296 unsigned int hostname_size = 256;
38182d90 1297 char *hostname = alloca (hostname_size);
c0c86835
KH		 1298
1299 /* Try to get the host name; if the buffer is too short, try
1300 again. Apparently, the only indication gethostname gives of
1301 whether the buffer was large enough is the presence or absence
1302 of a '\0' in the string. Eech. */
1303 for (;;)
1304 {
1305 gethostname (hostname, hostname_size - 1);
1306 hostname[hostname_size - 1] = '\0';
1307
1308 /* Was the buffer large enough for the '\0'? */
1309 if (strlen (hostname) < hostname_size - 1)
1310 break;
1311
1312 hostname_size <<= 1;
38182d90 1313 hostname = alloca (hostname_size);
c0c86835 1314 }
67004ffb 1315#ifdef HAVE_SOCKETS
c0c86835
KH		 1316 /* Turn the hostname into the official, fully-qualified hostname.
1317 Don't do this if we're going to dump; this can confuse system
1318 libraries on some machines and make the dumped emacs core dump. */
67004ffb 1319#ifndef CANNOT_DUMP
c0c86835 1320 if (initialized)
67004ffb 1321#endif /* not CANNOT_DUMP */
8966b757 1322 if (! strchr (hostname, '.'))
960d894c 1323 {
960d894c 1324 int count;
3d66b985
JD		 1325#ifdef HAVE_GETADDRINFO
1326 struct addrinfo *res;
1327 struct addrinfo hints;
1328 int ret;
1329
cf84bb53 1330 memset (&hints, 0, sizeof (hints));
3d66b985
JD		 1331 hints.ai_socktype = SOCK_STREAM;
1332 hints.ai_flags = AI_CANONNAME;
1333
960d894c
KH		 1334 for (count = 0;; count++)
1335 {
3d66b985
JD		 1336 if ((ret = getaddrinfo (hostname, NULL, &hints, &res)) == 0
1337 || ret != EAI_AGAIN)
1338 break;
1339
1340 if (count >= 5)
1341 break;
1342 Fsleep_for (make_number (1), Qnil);
1343 }
1344
1345 if (ret == 0)
1346 {
1347 struct addrinfo *it = res;
1348 while (it)
1349 {
1350 char *fqdn = it->ai_canonname;
8966b757 1351 if (fqdn && strchr (fqdn, '.')
3d66b985
JD		 1352 && strcmp (fqdn, "localhost.localdomain") != 0)
1353 break;
1354 it = it->ai_next;
1355 }
1356 if (it)
1357 {
1358 hostname = alloca (strlen (it->ai_canonname) + 1);
1359 strcpy (hostname, it->ai_canonname);
1360 }
1361 freeaddrinfo (res);
1362 }
1363#else /* !HAVE_GETADDRINFO */
1364 struct hostent *hp;
1365 for (count = 0;; count++)
1366 {
1367
e24f1d55 1368#ifdef TRY_AGAIN
960d894c 1369 h_errno = 0;
e24f1d55 1370#endif
960d894c 1371 hp = gethostbyname (hostname);
efa04277 1372#ifdef TRY_AGAIN
960d894c
KH		 1373 if (! (hp == 0 && h_errno == TRY_AGAIN))
1374#endif
3d66b985 1375
960d894c 1376 break;
3d66b985 1377
960d894c
KH		 1378 if (count >= 5)
1379 break;
1380 Fsleep_for (make_number (1), Qnil);
1381 }
3d66b985 1382
960d894c
KH		 1383 if (hp)
1384 {
1385 char *fqdn = (char *) hp->h_name;
960d894c 1386
8966b757 1387 if (!strchr (fqdn, '.'))
960d894c
KH		 1388 {
1389 /* We still don't have a fully qualified domain name.
1390 Try to find one in the list of alternate names */
1391 char **alias = hp->h_aliases;
923721f4 1392 while (*alias
8966b757 1393 && (!strchr (*alias, '.')
923721f4 1394 || !strcmp (*alias, "localhost.localdomain")))
960d894c
KH		 1395 alias++;
1396 if (*alias)
1397 fqdn = *alias;
1398 }
1399 hostname = fqdn;
960d894c 1400 }
3d66b985 1401#endif /* !HAVE_GETADDRINFO */
960d894c 1402 }
67004ffb 1403#endif /* HAVE_SOCKETS */
c0c86835 1404 Vsystem_name = build_string (hostname);
67004ffb 1405#endif /* HAVE_GETHOSTNAME */
c0c86835
KH		 1406 {
1407 unsigned char *p;
d5db4077 1408 for (p = SDATA (Vsystem_name); *p; p++)
c0c86835
KH		 1409 if (*p == ' ' || *p == '\t')
1410 *p = '-';
1411 }
67004ffb 1412}
86a5659e 1413\f
1fa53021 1414sigset_t empty_mask;
86a5659e 1415
4d7e6e51
PE		 1416static struct sigaction process_fatal_action;
1417
1418static int
1419emacs_sigaction_flags (void)
86a5659e 1420{
4d7e6e51 1421#ifdef SA_RESTART
0caaedb1
PE		 1422 /* SA_RESTART causes interruptible functions with timeouts (e.g.,
1423 'select') to reset their timeout on some platforms (e.g.,
1424 HP-UX 11), which is not what we want. Also, when Emacs is
1425 interactive, we don't want SA_RESTART because we need to poll
275464e7 1426 for pending input so we need long-running syscalls to be interrupted
4d7e6e51
PE		 1427 after a signal that sets pending_signals.
1428
1429 Non-interactive keyboard input goes through stdio, where we
1430 always want restartable system calls. */
ef874e3d 1431 if (noninteractive)
4d7e6e51 1432 return SA_RESTART;
e065a56e 1433#endif
4d7e6e51
PE		 1434 return 0;
1435}
1436
1437/* Store into *ACTION a signal action suitable for Emacs, with handler
1438 HANDLER. */
1439void
1440emacs_sigaction_init (struct sigaction *action, signal_handler_t handler)
1441{
1442 sigemptyset (&action->sa_mask);
1443
1444 /* When handling a signal, block nonfatal system signals that are caught
1445 by Emacs. This makes race conditions less likely. */
1446 sigaddset (&action->sa_mask, SIGALRM);
1447#ifdef SIGCHLD
1448 sigaddset (&action->sa_mask, SIGCHLD);
1449#endif
1450#ifdef SIGDANGER
1451 sigaddset (&action->sa_mask, SIGDANGER);
1452#endif
d89460ed
PE		 1453#ifdef PROFILER_CPU_SUPPORT
1454 sigaddset (&action->sa_mask, SIGPROF);
1455#endif
4d7e6e51
PE		 1456#ifdef SIGWINCH
1457 sigaddset (&action->sa_mask, SIGWINCH);
1458#endif
1459 if (! noninteractive)
1460 {
1461 sigaddset (&action->sa_mask, SIGINT);
1462 sigaddset (&action->sa_mask, SIGQUIT);
1463#ifdef USABLE_SIGIO
1464 sigaddset (&action->sa_mask, SIGIO);
1465#endif
1466 }
1467
1468 if (! IEEE_FLOATING_POINT)
1469 sigaddset (&action->sa_mask, SIGFPE);
1470
1471 action->sa_handler = handler;
1472 action->sa_flags = emacs_sigaction_flags ();
86a5659e
JB		 1473}
1474
20ef56db 1475#ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
0caaedb1 1476static pthread_t main_thread;
20ef56db
PE		 1477#endif
1478
4d7e6e51
PE		 1479/* SIG has arrived at the current process. Deliver it to the main
1480 thread, which should handle it with HANDLER.
1481
1482 If we are on the main thread, handle the signal SIG with HANDLER.
20ef56db
PE		 1483 Otherwise, redirect the signal to the main thread, blocking it from
1484 this thread. POSIX says any thread can receive a signal that is
1485 associated with a process, process group, or asynchronous event.
1486 On GNU/Linux that is not true, but for other systems (FreeBSD at
1487 least) it is. */
1488void
4d7e6e51 1489deliver_process_signal (int sig, signal_handler_t handler)
20ef56db
PE		 1490{
1491 /* Preserve errno, to avoid race conditions with signal handlers that
1492 might change errno. Races can occur even in single-threaded hosts. */
1493 int old_errno = errno;
1494
1495 bool on_main_thread = true;
1496#ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1497 if (! pthread_equal (pthread_self (), main_thread))
1498 {
1499 sigset_t blocked;
1500 sigemptyset (&blocked);
1501 sigaddset (&blocked, sig);
1502 pthread_sigmask (SIG_BLOCK, &blocked, 0);
1503 pthread_kill (main_thread, sig);
1504 on_main_thread = false;
1505 }
1506#endif
1507 if (on_main_thread)
1508 handler (sig);
1509
1510 errno = old_errno;
1511}
4d7e6e51
PE		 1512
1513/* Static location to save a fatal backtrace in a thread.
1514 FIXME: If two subsidiary threads fail simultaneously, the resulting
1515 backtrace may be garbage. */
1516enum { BACKTRACE_LIMIT_MAX = 500 };
1517static void *thread_backtrace_buffer[BACKTRACE_LIMIT_MAX + 1];
1518static int thread_backtrace_npointers;
1519
1520/* SIG has arrived at the current thread.
1521 If we are on the main thread, handle the signal SIG with HANDLER.
1522 Otherwise, this is a fatal error in the handling thread. */
1523static void
1524deliver_thread_signal (int sig, signal_handler_t handler)
1525{
1526 int old_errno = errno;
1527
1528#ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1529 if (! pthread_equal (pthread_self (), main_thread))
1530 {
1531 thread_backtrace_npointers
1532 = backtrace (thread_backtrace_buffer, BACKTRACE_LIMIT_MAX);
1533 sigaction (sig, &process_fatal_action, 0);
1534 pthread_kill (main_thread, sig);
1535
1536 /* Avoid further damage while the main thread is exiting. */
1537 while (1)
1538 sigsuspend (&empty_mask);
1539 }
1540#endif
1541
1542 handler (sig);
1543 errno = old_errno;
1544}
86a5659e 1545\f
aa1ba90e
PE		 1546#if !HAVE_DECL_SYS_SIGLIST
1547# undef sys_siglist
ca9c0567 1548# define sys_siglist my_sys_siglist
aa1ba90e 1549static char const *sys_siglist[NSIG];
ca9c0567
PE		 1550#endif
1551
4d7e6e51
PE		 1552/* Handle bus errors, invalid instruction, etc. */
1553static void
1554handle_fatal_signal (int sig)
1555{
9d4dcdc9 1556 terminate_due_to_signal (sig, 40);
4d7e6e51
PE		 1557}
1558
1559static void
1560deliver_fatal_signal (int sig)
1561{
1562 deliver_process_signal (sig, handle_fatal_signal);
1563}
1564
1565static void
1566deliver_fatal_thread_signal (int sig)
1567{
1568 deliver_thread_signal (sig, handle_fatal_signal);
1569}
1570
1571static _Noreturn void
1572handle_arith_signal (int sig)
1573{
1574 pthread_sigmask (SIG_SETMASK, &empty_mask, 0);
1575 xsignal0 (Qarith_error);
1576}
1577
1578static void
1579deliver_arith_signal (int sig)
1580{
1581 deliver_thread_signal (sig, handle_arith_signal);
1582}
1583
1584/* Treat SIG as a terminating signal, unless it is already ignored and
1585 we are in --batch mode. Among other things, this makes nohup work. */
1586static void
1587maybe_fatal_sig (int sig)
1588{
1589 bool catch_sig = !noninteractive;
1590 if (!catch_sig)
1591 {
1592 struct sigaction old_action;
1593 sigaction (sig, 0, &old_action);
1594 catch_sig = old_action.sa_handler != SIG_IGN;
1595 }
1596 if (catch_sig)
1597 sigaction (sig, &process_fatal_action, 0);
1598}
1599
ca9c0567 1600void
4d7e6e51 1601init_signals (bool dumping)
ca9c0567 1602{
4d7e6e51
PE		 1603 struct sigaction thread_fatal_action;
1604 struct sigaction action;
1605
ca9c0567 1606 sigemptyset (&empty_mask);
ca9c0567 1607
20ef56db
PE		 1608#ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
1609 main_thread = pthread_self ();
1610#endif
1611
aa1ba90e 1612#if !HAVE_DECL_SYS_SIGLIST
ca9c0567
PE		 1613 if (! initialized)
1614 {
ca9c0567 1615 sys_siglist[SIGABRT] = "Aborted";
ca9c0567
PE		 1616# ifdef SIGAIO
1617 sys_siglist[SIGAIO] = "LAN I/O interrupt";
1618# endif
1619# ifdef SIGALRM
1620 sys_siglist[SIGALRM] = "Alarm clock";
1621# endif
1622# ifdef SIGBUS
1623 sys_siglist[SIGBUS] = "Bus error";
1624# endif
1625# ifdef SIGCLD
1626 sys_siglist[SIGCLD] = "Child status changed";
1627# endif
1628# ifdef SIGCHLD
1629 sys_siglist[SIGCHLD] = "Child status changed";
1630# endif
1631# ifdef SIGCONT
1632 sys_siglist[SIGCONT] = "Continued";
1633# endif
1634# ifdef SIGDANGER
1635 sys_siglist[SIGDANGER] = "Swap space dangerously low";
1636# endif
1637# ifdef SIGDGNOTIFY
1638 sys_siglist[SIGDGNOTIFY] = "Notification message in queue";
1639# endif
1640# ifdef SIGEMT
1641 sys_siglist[SIGEMT] = "Emulation trap";
1642# endif
ca9c0567 1643 sys_siglist[SIGFPE] = "Arithmetic exception";
ca9c0567
PE		 1644# ifdef SIGFREEZE
1645 sys_siglist[SIGFREEZE] = "SIGFREEZE";
1646# endif
1647# ifdef SIGGRANT
1648 sys_siglist[SIGGRANT] = "Monitor mode granted";
1649# endif
1650# ifdef SIGHUP
1651 sys_siglist[SIGHUP] = "Hangup";
1652# endif
ca9c0567 1653 sys_siglist[SIGILL] = "Illegal instruction";
ca9c0567 1654 sys_siglist[SIGINT] = "Interrupt";
ca9c0567
PE		 1655# ifdef SIGIO
1656 sys_siglist[SIGIO] = "I/O possible";
1657# endif
1658# ifdef SIGIOINT
1659 sys_siglist[SIGIOINT] = "I/O intervention required";
1660# endif
1661# ifdef SIGIOT
1662 sys_siglist[SIGIOT] = "IOT trap";
1663# endif
1664# ifdef SIGKILL
1665 sys_siglist[SIGKILL] = "Killed";
1666# endif
1667# ifdef SIGLOST
1668 sys_siglist[SIGLOST] = "Resource lost";
1669# endif
1670# ifdef SIGLWP
1671 sys_siglist[SIGLWP] = "SIGLWP";
1672# endif
1673# ifdef SIGMSG
1674 sys_siglist[SIGMSG] = "Monitor mode data available";
1675# endif
1676# ifdef SIGPHONE
1677 sys_siglist[SIGWIND] = "SIGPHONE";
1678# endif
1679# ifdef SIGPIPE
1680 sys_siglist[SIGPIPE] = "Broken pipe";
1681# endif
1682# ifdef SIGPOLL
1683 sys_siglist[SIGPOLL] = "Pollable event occurred";
1684# endif
1685# ifdef SIGPROF
1686 sys_siglist[SIGPROF] = "Profiling timer expired";
1687# endif
1688# ifdef SIGPTY
1689 sys_siglist[SIGPTY] = "PTY I/O interrupt";
1690# endif
1691# ifdef SIGPWR
1692 sys_siglist[SIGPWR] = "Power-fail restart";
1693# endif
1694# ifdef SIGQUIT
1695 sys_siglist[SIGQUIT] = "Quit";
1696# endif
1697# ifdef SIGRETRACT
40ba43b4 1698 sys_siglist[SIGRETRACT] = "Need to relinquish monitor mode";
ca9c0567
PE		 1699# endif
1700# ifdef SIGSAK
1701 sys_siglist[SIGSAK] = "Secure attention";
1702# endif
ca9c0567 1703 sys_siglist[SIGSEGV] = "Segmentation violation";
ca9c0567
PE		 1704# ifdef SIGSOUND
1705 sys_siglist[SIGSOUND] = "Sound completed";
1706# endif
1707# ifdef SIGSTOP
1708 sys_siglist[SIGSTOP] = "Stopped (signal)";
1709# endif
1710# ifdef SIGSTP
1711 sys_siglist[SIGSTP] = "Stopped (user)";
1712# endif
1713# ifdef SIGSYS
1714 sys_siglist[SIGSYS] = "Bad argument to system call";
1715# endif
ca9c0567 1716 sys_siglist[SIGTERM] = "Terminated";
ca9c0567
PE		 1717# ifdef SIGTHAW
1718 sys_siglist[SIGTHAW] = "SIGTHAW";
1719# endif
1720# ifdef SIGTRAP
1721 sys_siglist[SIGTRAP] = "Trace/breakpoint trap";
1722# endif
1723# ifdef SIGTSTP
1724 sys_siglist[SIGTSTP] = "Stopped (user)";
1725# endif
1726# ifdef SIGTTIN
1727 sys_siglist[SIGTTIN] = "Stopped (tty input)";
1728# endif
1729# ifdef SIGTTOU
1730 sys_siglist[SIGTTOU] = "Stopped (tty output)";
1731# endif
1732# ifdef SIGURG
1733 sys_siglist[SIGURG] = "Urgent I/O condition";
1734# endif
1735# ifdef SIGUSR1
1736 sys_siglist[SIGUSR1] = "User defined signal 1";
1737# endif
1738# ifdef SIGUSR2
1739 sys_siglist[SIGUSR2] = "User defined signal 2";
1740# endif
1741# ifdef SIGVTALRM
1742 sys_siglist[SIGVTALRM] = "Virtual timer expired";
1743# endif
1744# ifdef SIGWAITING
1745 sys_siglist[SIGWAITING] = "Process's LWPs are blocked";
1746# endif
1747# ifdef SIGWINCH
1748 sys_siglist[SIGWINCH] = "Window size changed";
1749# endif
1750# ifdef SIGWIND
1751 sys_siglist[SIGWIND] = "SIGWIND";
1752# endif
1753# ifdef SIGXCPU
1754 sys_siglist[SIGXCPU] = "CPU time limit exceeded";
1755# endif
1756# ifdef SIGXFSZ
1757 sys_siglist[SIGXFSZ] = "File size limit exceeded";
1758# endif
1759 }
aa1ba90e 1760#endif /* !HAVE_DECL_SYS_SIGLIST */
4d7e6e51
PE		 1761
1762 /* Don't alter signal handlers if dumping. On some machines,
1763 changing signal handlers sets static data that would make signals
1764 fail to work right when the dumped Emacs is run. */
1765 if (dumping)
1766 return;
1767
1768 sigfillset (&process_fatal_action.sa_mask);
1769 process_fatal_action.sa_handler = deliver_fatal_signal;
62a1d661 1770 process_fatal_action.sa_flags = emacs_sigaction_flags ();
4d7e6e51
PE		 1771
1772 sigfillset (&thread_fatal_action.sa_mask);
1773 thread_fatal_action.sa_handler = deliver_fatal_thread_signal;
1774 thread_fatal_action.sa_flags = process_fatal_action.sa_flags;
1775
1776 /* SIGINT may need special treatment on MS-Windows. See
1777 http://lists.gnu.org/archive/html/emacs-devel/2010-09/msg01062.html
1778 Please update the doc of kill-emacs, kill-emacs-hook, and
1779 NEWS if you change this. */
1780
1781 maybe_fatal_sig (SIGHUP);
1782 maybe_fatal_sig (SIGINT);
1783 maybe_fatal_sig (SIGTERM);
1784
1785 /* Emacs checks for write errors, so it can safely ignore SIGPIPE.
1786 However, in batch mode leave SIGPIPE alone, as that causes Emacs
1787 to behave more like typical batch applications do. */
1788 if (! noninteractive)
1789 signal (SIGPIPE, SIG_IGN);
1790
1791 sigaction (SIGQUIT, &process_fatal_action, 0);
1792 sigaction (SIGILL, &thread_fatal_action, 0);
1793 sigaction (SIGTRAP, &thread_fatal_action, 0);
1794
1795 /* Typically SIGFPE is thread-specific and is fatal, like SIGILL.
1796 But on a non-IEEE host SIGFPE can come from a trap in the Lisp
1797 interpreter's floating point operations, so treat SIGFPE as an
1798 arith-error if it arises in the main thread. */
1799 if (IEEE_FLOATING_POINT)
1800 sigaction (SIGFPE, &thread_fatal_action, 0);
1801 else
1802 {
1803 emacs_sigaction_init (&action, deliver_arith_signal);
1804 sigaction (SIGFPE, &action, 0);
1805 }
1806
1807#ifdef SIGUSR1
1808 add_user_signal (SIGUSR1, "sigusr1");
1809#endif
1810#ifdef SIGUSR2
1811 add_user_signal (SIGUSR2, "sigusr2");
1812#endif
1813 sigaction (SIGABRT, &thread_fatal_action, 0);
1814#ifdef SIGPRE
1815 sigaction (SIGPRE, &thread_fatal_action, 0);
1816#endif
1817#ifdef SIGORE
1818 sigaction (SIGORE, &thread_fatal_action, 0);
1819#endif
1820#ifdef SIGUME
1821 sigaction (SIGUME, &thread_fatal_action, 0);
1822#endif
1823#ifdef SIGDLK
1824 sigaction (SIGDLK, &process_fatal_action, 0);
1825#endif
1826#ifdef SIGCPULIM
1827 sigaction (SIGCPULIM, &process_fatal_action, 0);
1828#endif
1829#ifdef SIGIOT
1830 sigaction (SIGIOT, &thread_fatal_action, 0);
1831#endif
1832#ifdef SIGEMT
1833 sigaction (SIGEMT, &thread_fatal_action, 0);
1834#endif
1835#ifdef SIGBUS
1836 sigaction (SIGBUS, &thread_fatal_action, 0);
1837#endif
1838 sigaction (SIGSEGV, &thread_fatal_action, 0);
1839#ifdef SIGSYS
1840 sigaction (SIGSYS, &thread_fatal_action, 0);
1841#endif
1842 sigaction (SIGTERM, &process_fatal_action, 0);
1843#ifdef SIGPROF
d89460ed 1844 signal (SIGPROF, SIG_IGN);
4d7e6e51
PE		 1845#endif
1846#ifdef SIGVTALRM
1847 sigaction (SIGVTALRM, &process_fatal_action, 0);
1848#endif
1849#ifdef SIGXCPU
1850 sigaction (SIGXCPU, &process_fatal_action, 0);
1851#endif
1852#ifdef SIGXFSZ
1853 sigaction (SIGXFSZ, &process_fatal_action, 0);
1854#endif
1855
1856#ifdef SIGDANGER
1857 /* This just means available memory is getting low. */
1858 emacs_sigaction_init (&action, deliver_danger_signal);
1859 sigaction (SIGDANGER, &action, 0);
1860#endif
1861
1862 /* AIX-specific signals. */
1863#ifdef SIGGRANT
1864 sigaction (SIGGRANT, &process_fatal_action, 0);
1865#endif
1866#ifdef SIGMIGRATE
1867 sigaction (SIGMIGRATE, &process_fatal_action, 0);
1868#endif
1869#ifdef SIGMSG
1870 sigaction (SIGMSG, &process_fatal_action, 0);
1871#endif
1872#ifdef SIGRETRACT
1873 sigaction (SIGRETRACT, &process_fatal_action, 0);
1874#endif
1875#ifdef SIGSAK
1876 sigaction (SIGSAK, &process_fatal_action, 0);
1877#endif
1878#ifdef SIGSOUND
1879 sigaction (SIGSOUND, &process_fatal_action, 0);
1880#endif
1881#ifdef SIGTALRM
1882 sigaction (SIGTALRM, &thread_fatal_action, 0);
1883#endif
ca9c0567
PE		 1884}
1885\f
9927a7b1 1886#ifndef HAVE_RANDOM
4bb8c8b7
KH		 1887#ifdef random
1888#define HAVE_RANDOM
1889#endif
1890#endif
1891
1892/* Figure out how many bits the system's random number generator uses.
1893 `random' and `lrand48' are assumed to return 31 usable bits.
1894 BSD `rand' returns a 31 bit value but the low order bits are unusable;
1895 so we'll shift it and treat it like the 15-bit USG `rand'. */
1896
1897#ifndef RAND_BITS
1898# ifdef HAVE_RANDOM
1899# define RAND_BITS 31
1900# else /* !HAVE_RANDOM */
1901# ifdef HAVE_LRAND48
1902# define RAND_BITS 31
1903# define random lrand48
1904# else /* !HAVE_LRAND48 */
1905# define RAND_BITS 15
1906# if RAND_MAX == 32767
1907# define random rand
1908# else /* RAND_MAX != 32767 */
1909# if RAND_MAX == 2147483647
1910# define random() (rand () >> 16)
1911# else /* RAND_MAX != 2147483647 */
1912# ifdef USG
1913# define random rand
1914# else
1915# define random() (rand () >> 16)
2a633456 1916# endif /* !USG */
4bb8c8b7
KH		 1917# endif /* RAND_MAX != 2147483647 */
1918# endif /* RAND_MAX != 32767 */
1919# endif /* !HAVE_LRAND48 */
1920# endif /* !HAVE_RANDOM */
1921#endif /* !RAND_BITS */
2e46c7c6 1922
4bb8c8b7 1923void
0e23ef9d 1924seed_random (void *seed, ptrdiff_t seed_size)
86a5659e 1925{
33634217 1926#if defined HAVE_RANDOM || ! defined HAVE_LRAND48
0e23ef9d
PE		 1927 unsigned int arg = 0;
1928#else
1929 long int arg = 0;
1930#endif
1931 unsigned char *argp = (unsigned char *) &arg;
1932 unsigned char *seedp = seed;
1933 ptrdiff_t i;
1934 for (i = 0; i < seed_size; i++)
1935 argp[i % sizeof arg] ^= seedp[i];
4bb8c8b7 1936#ifdef HAVE_RANDOM
0e23ef9d 1937 srandom (arg);
f8b53a82 1938#else
4bb8c8b7 1939# ifdef HAVE_LRAND48
76425a49 1940 srand48 (arg);
4bb8c8b7 1941# else
0e23ef9d 1942 srand (arg);
4bb8c8b7 1943# endif
2e46c7c6 1944#endif
86a5659e
JB		 1945}
1946
0e23ef9d
PE		 1947void
1948init_random (void)
1949{
1950 EMACS_TIME t = current_emacs_time ();
1951 uintmax_t v = getpid () ^ EMACS_SECS (t) ^ EMACS_NSECS (t);
1952 seed_random (&v, sizeof v);
1953}
1954
4bb8c8b7 1955/*
d8ed26bd
PE		 1956 * Return a nonnegative random integer out of whatever we've got.
1957 * It contains enough bits to make a random (signed) Emacs fixnum.
4bb8c8b7
KH		 1958 * This suffices even for a 64-bit architecture with a 15-bit rand.
1959 */
ede49d71 1960EMACS_INT
971de7fb 1961get_random (void)
4bb8c8b7 1962{
ede49d71
PE		 1963 EMACS_UINT val = 0;
1964 int i;
d8ed26bd
PE		 1965 for (i = 0; i < (FIXNUM_BITS + RAND_BITS - 1) / RAND_BITS; i++)
1966 val = (random () ^ (val << RAND_BITS)
1967 ^ (val >> (BITS_PER_EMACS_INT - RAND_BITS)));
1968 val ^= val >> (BITS_PER_EMACS_INT - FIXNUM_BITS);
1969 return val & INTMASK;
4bb8c8b7 1970}
7088d1ca 1971
55e5faa1
PE		 1972#ifndef HAVE_SNPRINTF
1973/* Approximate snprintf as best we can on ancient hosts that lack it. */
1974int
1975snprintf (char *buf, size_t bufsize, char const *format, ...)
1976{
1977 ptrdiff_t size = min (bufsize, PTRDIFF_MAX);
1978 ptrdiff_t nbytes = size - 1;
1979 va_list ap;
1980
1981 if (size)
1982 {
1983 va_start (ap, format);
1984 nbytes = doprnt (buf, size, format, 0, ap);
1985 va_end (ap);
1986 }
1987
1988 if (nbytes == size - 1)
1989 {
1990 /* Calculate the length of the string that would have been created
1991 had the buffer been large enough. */
1992 char stackbuf[4000];
1993 char *b = stackbuf;
1994 ptrdiff_t bsize = sizeof stackbuf;
1995 va_start (ap, format);
1996 nbytes = evxprintf (&b, &bsize, stackbuf, -1, format, ap);
1997 va_end (ap);
1998 if (b != stackbuf)
1999 xfree (b);
2000 }
2001
2002 if (INT_MAX < nbytes)
2003 {
31bed486 2004#ifdef EOVERFLOW
55e5faa1 2005 errno = EOVERFLOW;
31bed486
EZ		 2006#else
2007 errno = EDOM;
2008#endif
55e5faa1
PE		 2009 return -1;
2010 }
2011 return nbytes;
2012}
2013#endif
86a5659e 2014\f
cf29dd84
PE		 2015/* If a backtrace is available, output the top lines of it to stderr.
2016 Do not output more than BACKTRACE_LIMIT or BACKTRACE_LIMIT_MAX lines.
2017 This function may be called from a signal handler, so it should
2018 not invoke async-unsafe functions like malloc. */
2019void
2020emacs_backtrace (int backtrace_limit)
2021{
4d7e6e51 2022 void *main_backtrace_buffer[BACKTRACE_LIMIT_MAX + 1];
cf29dd84 2023 int bounded_limit = min (backtrace_limit, BACKTRACE_LIMIT_MAX);
4d7e6e51
PE		 2024 void *buffer;
2025 int npointers;
2026
2027 if (thread_backtrace_npointers)
2028 {
2029 buffer = thread_backtrace_buffer;
2030 npointers = thread_backtrace_npointers;
2031 }
2032 else
2033 {
2034 buffer = main_backtrace_buffer;
2035 npointers = backtrace (buffer, bounded_limit + 1);
2036 }
2037
cf29dd84 2038 if (npointers)
4d7e6e51
PE		 2039 {
2040 ignore_value (write (STDERR_FILENO, "\nBacktrace:\n", 12));
2041 backtrace_symbols_fd (buffer, npointers, STDERR_FILENO);
2042 if (bounded_limit < npointers)
2043 ignore_value (write (STDERR_FILENO, "...\n", 4));
2044 }
cf29dd84
PE		 2045}
2046\f
1088b922 2047#ifndef HAVE_NTGUI
1088b922
PE		 2048void
2049emacs_abort (void)
2050{
4d7e6e51 2051 terminate_due_to_signal (SIGABRT, 10);
1088b922
PE		 2052}
2053#endif
2054
86a5659e 2055int
971de7fb 2056emacs_open (const char *path, int oflag, int mode)
86a5659e
JB		 2057{
2058 register int rtnval;
68c45bf0 2059
86a5659e 2060 while ((rtnval = open (path, oflag, mode)) == -1
275464e7
SM		 2061 && (errno == EINTR))
2062 QUIT;
86a5659e
JB		 2063 return (rtnval);
2064}
2065
dfcf069d 2066int
971de7fb 2067emacs_close (int fd)
86a5659e 2068{
fe111daf 2069 int did_retry = 0;
86a5659e
JB		 2070 register int rtnval;
2071
2072 while ((rtnval = close (fd)) == -1
fe111daf
KH		 2073 && (errno == EINTR))
2074 did_retry = 1;
2075
2076 /* If close is interrupted SunOS 4.1 may or may not have closed the
2077 file descriptor. If it did the second close will fail with
2078 errno = EBADF. That means we have succeeded. */
2079 if (rtnval == -1 && did_retry && errno == EBADF)
2080 return 0;
2081
86a5659e
JB		 2082 return rtnval;
2083}
2084
1963a2e0
PE		 2085/* Maximum number of bytes to read or write in a single system call.
2086 This works around a serious bug in Linux kernels before 2.6.16; see
2087 <https://bugzilla.redhat.com/show_bug.cgi?format=multiple&id=612839>.
2088 It's likely to work around similar bugs in other operating systems, so do it
2089 on all platforms. Round INT_MAX down to a page size, with the conservative
2090 assumption that page sizes are at most 2**18 bytes (any kernel with a
2091 page size larger than that shouldn't have the bug). */
2092#ifndef MAX_RW_COUNT
2093#define MAX_RW_COUNT (INT_MAX >> 18 << 18)
2094#endif
2095
273a5f82
PE		 2096/* Read from FILEDESC to a buffer BUF with size NBYTE, retrying if interrupted.
2097 Return the number of bytes read, which might be less than NBYTE.
2098 On error, set errno and return -1. */
d311d28c
PE		 2099ptrdiff_t
2100emacs_read (int fildes, char *buf, ptrdiff_t nbyte)
86a5659e 2101{
8a2cbd72 2102 register ssize_t rtnval;
177c0ea7 2103
71b41406
PE		 2104 /* There is no need to check against MAX_RW_COUNT, since no caller ever
2105 passes a size that large to emacs_read. */
2106
2107 while ((rtnval = read (fildes, buf, nbyte)) == -1
275464e7
SM		 2108 && (errno == EINTR))
2109 QUIT;
86a5659e
JB		 2110 return (rtnval);
2111}
2112
273a5f82
PE		 2113/* Write to FILEDES from a buffer BUF with size NBYTE, retrying if interrupted
2114 or if a partial write occurs. Return the number of bytes written, setting
2115 errno if this is less than NBYTE. */
d311d28c
PE		 2116ptrdiff_t
2117emacs_write (int fildes, const char *buf, ptrdiff_t nbyte)
86a5659e 2118{
273a5f82 2119 ssize_t rtnval;
d311d28c 2120 ptrdiff_t bytes_written;
28272684 2121
b95520f5
BF		 2122 bytes_written = 0;
2123
273a5f82 2124 while (nbyte > 0)
b95520f5 2125 {
1963a2e0 2126 rtnval = write (fildes, buf, min (nbyte, MAX_RW_COUNT));
b95520f5 2127
273a5f82 2128 if (rtnval < 0)
b95520f5
BF		 2129 {
2130 if (errno == EINTR)
77220eeb 2131 {
77220eeb
SM		 2132 /* I originally used `QUIT' but that might causes files to
2133 be truncated if you hit C-g in the middle of it. --Stef */
4d7e6e51
PE		 2134 if (pending_signals)
2135 process_pending_signals ();
77220eeb
SM		 2136 continue;
2137 }
b95520f5 2138 else
273a5f82 2139 break;
b95520f5
BF		 2140 }
2141
2142 buf += rtnval;
2143 nbyte -= rtnval;
2144 bytes_written += rtnval;
2145 }
273a5f82 2146
b95520f5 2147 return (bytes_written);
86a5659e 2148}
d1fdcab7
PE		 2149
2150static struct allocator const emacs_norealloc_allocator =
2151 { xmalloc, NULL, xfree, memory_full };
2152
2153/* Get the symbolic link value of FILENAME. Return a pointer to a
2154 NUL-terminated string. If readlink fails, return NULL and set
2155 errno. If the value fits in INITIAL_BUF, return INITIAL_BUF.
2156 Otherwise, allocate memory and return a pointer to that memory. If
2157 memory allocation fails, diagnose and fail without returning. If
2158 successful, store the length of the symbolic link into *LINKLEN. */
2159char *
2160emacs_readlink (char const *filename, char initial_buf[READLINK_BUFSIZE])
2161{
2162 return careadlinkat (AT_FDCWD, filename, initial_buf, READLINK_BUFSIZE,
2163 &emacs_norealloc_allocator, careadlinkatcwd);
2164}
86a5659e
JB		 2165\f
2166#ifdef USG
2167/*
2168 * All of the following are for USG.
2169 *
2170 * On USG systems the system calls are INTERRUPTIBLE by signals
2171 * that the user program has elected to catch. Thus the system call
2172 * must be retried in these cases. To handle this without massive
2173 * changes in the source code, we remap the standard system call names
2174 * to names for our own functions in sysdep.c that do the system call
2175 * with retries. Actually, for portability reasons, it is good
2176 * programming practice, as this example shows, to limit all actual
eb8c3be9 2177 * system calls to a single occurrence in the source. Sure, this
86a5659e
JB		 2178 * adds an extra level of function call overhead but it is almost
2179 * always negligible. Fred Fish, Unisoft Systems Inc.
2180 */
2181
86a5659e
JB		 2182/*
2183 * Warning, this function may not duplicate 4.2 action properly
2184 * under error conditions.
2185 */
2186
1db4583a 2187#if !defined (HAVE_GETWD) || defined (BROKEN_GETWD)
15dfd3d9 2188
86a5659e
JB		 2189#ifndef MAXPATHLEN
2190/* In 4.1, param.h fails to define this. */
2191#define MAXPATHLEN 1024
2192#endif
2193
86a5659e 2194char *
cf84bb53 2195getwd (char *pathname)
86a5659e
JB		 2196{
2197 char *npath, *spath;
cf84bb53 2198 extern char *getcwd (char *, size_t);
86a5659e 2199
4d7e6e51 2200 block_input (); /* getcwd uses malloc */
86a5659e 2201 spath = npath = getcwd ((char *) 0, MAXPATHLEN);
f4a7e5bd 2202 if (spath == 0)
18b6bc73 2203 {
4d7e6e51 2204 unblock_input ();
18b6bc73
GM		 2205 return spath;
2206 }
86a5659e
JB		 2207 /* On Altos 3068, getcwd can return @hostname/dir, so discard
2208 up to first slash. Should be harmless on other systems. */
2209 while (*npath && *npath != '/')
2210 npath++;
2211 strcpy (pathname, npath);
2212 free (spath); /* getcwd uses malloc */
4d7e6e51 2213 unblock_input ();
86a5659e
JB		 2214 return pathname;
2215}
2216
1db4583a 2217#endif /* !defined (HAVE_GETWD) || defined (BROKEN_GETWD) */
86a5659e
JB		 2218#endif /* USG */
2219\f
86a5659e
JB		 2220/* Directory routines for systems that don't have them. */
2221
1c97e857 2222#ifdef HAVE_DIRENT_H
86a5659e
JB		 2223
2224#include <dirent.h>
2225
9d9a7716 2226#if !defined (HAVE_CLOSEDIR)
cfdc57af 2227
86a5659e 2228int
9d9a7716 2229closedir (DIR *dirp /* stream from opendir */)
86a5659e 2230{
cfdc57af
RS		 2231 int rtnval;
2232
68c45bf0 2233 rtnval = emacs_close (dirp->dd_fd);
98c6f1e3 2234 xfree (dirp);
cfdc57af
RS		 2235
2236 return rtnval;
86a5659e 2237}
9d9a7716 2238#endif /* not HAVE_CLOSEDIR */
1c97e857 2239#endif /* HAVE_DIRENT_H */
86a5659e 2240
23524fb9 2241\f
d35af63c
PE		 2242/* Return a struct timeval that is roughly equivalent to T.
2243 Use the least timeval not less than T.
2244 Return an extremal value if the result would overflow. */
2245struct timeval
2246make_timeval (EMACS_TIME t)
2247{
2248 struct timeval tv;
2249 tv.tv_sec = t.tv_sec;
2250 tv.tv_usec = t.tv_nsec / 1000;
2251
2252 if (t.tv_nsec % 1000 != 0)
2253 {
2254 if (tv.tv_usec < 999999)
2255 tv.tv_usec++;
2256 else if (tv.tv_sec < TYPE_MAXIMUM (time_t))
2257 {
2258 tv.tv_sec++;
2259 tv.tv_usec = 0;
2260 }
2261 }
2262
2263 return tv;
2264}
2265
2266/* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2267 ATIME and MTIME, respectively.
2268 FD must be either negative -- in which case it is ignored --
2269 or a file descriptor that is open on FILE.
2270 If FD is nonnegative, then FILE can be NULL. */
53ea491a 2271int
d35af63c
PE		 2272set_file_times (int fd, const char *filename,
2273 EMACS_TIME atime, EMACS_TIME mtime)
2274{
2275 struct timespec timespec[2];
2276 timespec[0] = atime;
2277 timespec[1] = mtime;
2278 return fdutimens (fd, filename, timespec);
53ea491a
KH		 2279}
2280\f
aa1ba90e
PE		 2281/* Like strsignal, except async-signal-safe, and this function typically
2282 returns a string in the C locale rather than the current locale. */
2283char const *
2284safe_strsignal (int code)
68c45bf0 2285{
aa1ba90e 2286 char const *signame = 0;
68c45bf0
PE		 2287
2288 if (0 <= code && code < NSIG)
aa1ba90e
PE		 2289 signame = sys_siglist[code];
2290 if (! signame)
2291 signame = "Unknown signal";
c4ea52a6 2292
68c45bf0
PE		 2293 return signame;
2294}
d888760c 2295\f
a7ebc409 2296#ifndef DOS_NT
d888760c 2297/* For make-serial-process */
cf84bb53
JB		 2298int
2299serial_open (char *port)
d888760c
GM		 2300{
2301 int fd = -1;
2302
2303 fd = emacs_open ((char*) port,
2304 O_RDWR
2305#ifdef O_NONBLOCK
2306 | O_NONBLOCK
2307#else
2308 | O_NDELAY
2309#endif
2310#ifdef O_NOCTTY
2311 | O_NOCTTY
2312#endif
2313 , 0);
2314 if (fd < 0)
2315 {
2316 error ("Could not open %s: %s",
2317 port, emacs_strerror (errno));
2318 }
2319#ifdef TIOCEXCL
2320 ioctl (fd, TIOCEXCL, (char *) 0);
2321#endif
2322
2323 return fd;
2324}
759d3f32
SM		 2325
2326#if !defined (HAVE_CFMAKERAW)
2327/* Workaround for targets which are missing cfmakeraw. */
2328/* Pasted from man page. */
cf84bb53
JB		 2329static void
2330cfmakeraw (struct termios *termios_p)
759d3f32
SM		 2331{
2332 termios_p->c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
2333 termios_p->c_oflag &= ~OPOST;
2334 termios_p->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
2335 termios_p->c_cflag &= ~(CSIZE|PARENB);
2336 termios_p->c_cflag |= CS8;
2337}
2338#endif /* !defined (HAVE_CFMAKERAW */
2339
2340#if !defined (HAVE_CFSETSPEED)
2341/* Workaround for targets which are missing cfsetspeed. */
cf84bb53
JB		 2342static int
2343cfsetspeed (struct termios *termios_p, speed_t vitesse)
759d3f32
SM		 2344{
2345 return (cfsetispeed (termios_p, vitesse)
2346 + cfsetospeed (termios_p, vitesse));
2347}
2348#endif
2349
d888760c
GM		 2350/* For serial-process-configure */
2351void
2352serial_configure (struct Lisp_Process *p,
cf84bb53 2353 Lisp_Object contact)
d888760c
GM		 2354{
2355 Lisp_Object childp2 = Qnil;
2356 Lisp_Object tem = Qnil;
2357 struct termios attr;
2358 int err = -1;
2359 char summary[4] = "???"; /* This usually becomes "8N1". */
2360
4d2b044c 2361 childp2 = Fcopy_sequence (p->childp);
d888760c
GM		 2362
2363 /* Read port attributes and prepare default configuration. */
2364 err = tcgetattr (p->outfd, &attr);
2365 if (err != 0)
2366 error ("tcgetattr() failed: %s", emacs_strerror (errno));
2367 cfmakeraw (&attr);
2368#if defined (CLOCAL)
2369 attr.c_cflag |= CLOCAL;
2370#endif
2371#if defined (CREAD)
6d1921be 2372 attr.c_cflag |= CREAD;
d888760c
GM		 2373#endif
2374
2375 /* Configure speed. */
2376 if (!NILP (Fplist_member (contact, QCspeed)))
2377 tem = Fplist_get (contact, QCspeed);
2378 else
4d2b044c 2379 tem = Fplist_get (p->childp, QCspeed);
d888760c
GM		 2380 CHECK_NUMBER (tem);
2381 err = cfsetspeed (&attr, XINT (tem));
2382 if (err != 0)
c2982e87 2383 error ("cfsetspeed(%"pI"d) failed: %s", XINT (tem),
5fdb398c 2384 emacs_strerror (errno));
d888760c
GM		 2385 childp2 = Fplist_put (childp2, QCspeed, tem);
2386
2387 /* Configure bytesize. */
2388 if (!NILP (Fplist_member (contact, QCbytesize)))
2389 tem = Fplist_get (contact, QCbytesize);
2390 else
4d2b044c 2391 tem = Fplist_get (p->childp, QCbytesize);
d888760c
GM		 2392 if (NILP (tem))
2393 tem = make_number (8);
2394 CHECK_NUMBER (tem);
2395 if (XINT (tem) != 7 && XINT (tem) != 8)
2396 error (":bytesize must be nil (8), 7, or 8");
cf84bb53 2397 summary[0] = XINT (tem) + '0';
d888760c
GM		 2398#if defined (CSIZE) && defined (CS7) && defined (CS8)
2399 attr.c_cflag &= ~CSIZE;
2400 attr.c_cflag |= ((XINT (tem) == 7) ? CS7 : CS8);
2401#else
16bad4dd 2402 /* Don't error on bytesize 8, which should be set by cfmakeraw. */
d888760c
GM		 2403 if (XINT (tem) != 8)
2404 error ("Bytesize cannot be changed");
2405#endif
2406 childp2 = Fplist_put (childp2, QCbytesize, tem);
2407
2408 /* Configure parity. */
2409 if (!NILP (Fplist_member (contact, QCparity)))
2410 tem = Fplist_get (contact, QCparity);
2411 else
4d2b044c 2412 tem = Fplist_get (p->childp, QCparity);
d888760c
GM		 2413 if (!NILP (tem) && !EQ (tem, Qeven) && !EQ (tem, Qodd))
2414 error (":parity must be nil (no parity), `even', or `odd'");
2415#if defined (PARENB) && defined (PARODD) && defined (IGNPAR) && defined (INPCK)
2416 attr.c_cflag &= ~(PARENB | PARODD);
2417 attr.c_iflag &= ~(IGNPAR | INPCK);
2418 if (NILP (tem))
2419 {
2420 summary[1] = 'N';
2421 }
2422 else if (EQ (tem, Qeven))
2423 {
2424 summary[1] = 'E';
2425 attr.c_cflag |= PARENB;
2426 attr.c_iflag |= (IGNPAR | INPCK);
2427 }
2428 else if (EQ (tem, Qodd))
2429 {
2430 summary[1] = 'O';
2431 attr.c_cflag |= (PARENB | PARODD);
2432 attr.c_iflag |= (IGNPAR | INPCK);
2433 }
2434#else
16bad4dd 2435 /* Don't error on no parity, which should be set by cfmakeraw. */
d888760c
GM		 2436 if (!NILP (tem))
2437 error ("Parity cannot be configured");
2438#endif
2439 childp2 = Fplist_put (childp2, QCparity, tem);
2440
2441 /* Configure stopbits. */
2442 if (!NILP (Fplist_member (contact, QCstopbits)))
2443 tem = Fplist_get (contact, QCstopbits);
2444 else
4d2b044c 2445 tem = Fplist_get (p->childp, QCstopbits);
d888760c
GM		 2446 if (NILP (tem))
2447 tem = make_number (1);
2448 CHECK_NUMBER (tem);
2449 if (XINT (tem) != 1 && XINT (tem) != 2)
2450 error (":stopbits must be nil (1 stopbit), 1, or 2");
2451 summary[2] = XINT (tem) + '0';
2452#if defined (CSTOPB)
2453 attr.c_cflag &= ~CSTOPB;
2454 if (XINT (tem) == 2)
2455 attr.c_cflag |= CSTOPB;
2456#else
16bad4dd 2457 /* Don't error on 1 stopbit, which should be set by cfmakeraw. */
d888760c
GM		 2458 if (XINT (tem) != 1)
2459 error ("Stopbits cannot be configured");
2460#endif
2461 childp2 = Fplist_put (childp2, QCstopbits, tem);
2462
2463 /* Configure flowcontrol. */
2464 if (!NILP (Fplist_member (contact, QCflowcontrol)))
2465 tem = Fplist_get (contact, QCflowcontrol);
2466 else
4d2b044c 2467 tem = Fplist_get (p->childp, QCflowcontrol);
d888760c
GM		 2468 if (!NILP (tem) && !EQ (tem, Qhw) && !EQ (tem, Qsw))
2469 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
2470#if defined (CRTSCTS)
2471 attr.c_cflag &= ~CRTSCTS;
2472#endif
2473#if defined (CNEW_RTSCTS)
2474 attr.c_cflag &= ~CNEW_RTSCTS;
2475#endif
2476#if defined (IXON) && defined (IXOFF)
2477 attr.c_iflag &= ~(IXON | IXOFF);
2478#endif
2479 if (NILP (tem))
2480 {
2481 /* Already configured. */
2482 }
2483 else if (EQ (tem, Qhw))
2484 {
2485#if defined (CRTSCTS)
2486 attr.c_cflag |= CRTSCTS;
2487#elif defined (CNEW_RTSCTS)
2488 attr.c_cflag |= CNEW_RTSCTS;
2489#else
2490 error ("Hardware flowcontrol (RTS/CTS) not supported");
2491#endif
2492 }
2493 else if (EQ (tem, Qsw))
2494 {
2495#if defined (IXON) && defined (IXOFF)
2496 attr.c_iflag |= (IXON | IXOFF);
2497#else
2498 error ("Software flowcontrol (XON/XOFF) not supported");
2499#endif
2500 }
2501 childp2 = Fplist_put (childp2, QCflowcontrol, tem);
2502
2503 /* Activate configuration. */
2504 err = tcsetattr (p->outfd, TCSANOW, &attr);
2505 if (err != 0)
2506 error ("tcsetattr() failed: %s", emacs_strerror (errno));
2507
2508 childp2 = Fplist_put (childp2, QCsummary, build_string (summary));
6a09a33b 2509 pset_childp (p, childp2);
d888760c 2510}
a7ebc409 2511#endif /* not DOS_NT */
06e111a6
DN		 2512\f
2513/* System depended enumeration of and access to system processes a-la ps(1). */
2514
2515#ifdef HAVE_PROCFS
2516
2517/* Process enumeration and access via /proc. */
2518
2519Lisp_Object
971de7fb 2520list_system_processes (void)
06e111a6
DN		 2521{
2522 Lisp_Object procdir, match, proclist, next;
2523 struct gcpro gcpro1, gcpro2;
2524 register Lisp_Object tail;
2525
2526 GCPRO2 (procdir, match);
2527 /* For every process on the system, there's a directory in the
2528 "/proc" pseudo-directory whose name is the numeric ID of that
2529 process. */
2530 procdir = build_string ("/proc");
2531 match = build_string ("[0-9]+");
86ec63ba 2532 proclist = directory_files_internal (procdir, Qnil, match, Qt, 0, Qnil);
06e111a6
DN		 2533
2534 /* `proclist' gives process IDs as strings. Destructively convert
2535 each string into a number. */
2536 for (tail = proclist; CONSP (tail); tail = next)
2537 {
2538 next = XCDR (tail);
2539 XSETCAR (tail, Fstring_to_number (XCAR (tail), Qnil));
2540 }
2541 UNGCPRO;
2542
2543 /* directory_files_internal returns the files in reverse order; undo
2544 that. */
2545 proclist = Fnreverse (proclist);
2546 return proclist;
2547}
2548
f01769f9 2549#elif defined BSD_SYSTEM
b91b7e4d
EW		 2550
2551Lisp_Object
5790543d 2552list_system_processes (void)
b91b7e4d 2553{
f3047c75 2554#if defined DARWIN_OS || defined __NetBSD__ || defined __OpenBSD__
f01769f9
LL		 2555 int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_ALL};
2556#else
b91b7e4d 2557 int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_PROC};
f01769f9 2558#endif
b91b7e4d
EW		 2559 size_t len;
2560 struct kinfo_proc *procs;
2561 size_t i;
2562
2563 struct gcpro gcpro1;
2564 Lisp_Object proclist = Qnil;
2565
2566 if (sysctl (mib, 3, NULL, &len, NULL, 0) != 0)
2567 return proclist;
5790543d 2568
b91b7e4d
EW		 2569 procs = xmalloc (len);
2570 if (sysctl (mib, 3, procs, &len, NULL, 0) != 0)
2571 {
2572 xfree (procs);
2573 return proclist;
2574 }
5790543d 2575
b91b7e4d
EW		 2576 GCPRO1 (proclist);
2577 len /= sizeof (struct kinfo_proc);
2578 for (i = 0; i < len; i++)
f01769f9 2579 {
f3047c75 2580#if defined DARWIN_OS || defined __NetBSD__
f01769f9 2581 proclist = Fcons (make_fixnum_or_float (procs[i].kp_proc.p_pid), proclist);
7dca65a4
PE		 2582#elif defined __OpenBSD__
2583 proclist = Fcons (make_fixnum_or_float (procs[i].p_pid), proclist);
f01769f9
LL		 2584#else
2585 proclist = Fcons (make_fixnum_or_float (procs[i].ki_pid), proclist);
2586#endif
2587 }
b91b7e4d 2588 UNGCPRO;
5790543d 2589
b91b7e4d
EW		 2590 xfree (procs);
2591
2592 return proclist;
2593}
2594
f8d23104
DN		 2595/* The WINDOWSNT implementation is in w32.c.
2596 The MSDOS implementation is in dosfns.c. */
c4605e09 2597#elif !defined (WINDOWSNT) && !defined (MSDOS)
06e111a6
DN		 2598
2599Lisp_Object
cf84bb53 2600list_system_processes (void)
06e111a6
DN		 2601{
2602 return Qnil;
2603}
91c85b70
EZ		 2604
2605#endif /* !defined (WINDOWSNT) */
06e111a6
DN		 2606
2607#ifdef GNU_LINUX
d35af63c
PE		 2608static EMACS_TIME
2609time_from_jiffies (unsigned long long tval, long hz)
2610{
2611 unsigned long long s = tval / hz;
2612 unsigned long long frac = tval % hz;
2613 int ns;
d35af63c
PE		 2614
2615 if (TYPE_MAXIMUM (time_t) < s)
2616 time_overflow ();
2617 if (LONG_MAX - 1 <= ULLONG_MAX / EMACS_TIME_RESOLUTION
2618 || frac <= ULLONG_MAX / EMACS_TIME_RESOLUTION)
2619 ns = frac * EMACS_TIME_RESOLUTION / hz;
06e111a6 2620 else
d35af63c
PE		 2621 {
2622 /* This is reachable only in the unlikely case that HZ * HZ
2623 exceeds ULLONG_MAX. It calculates an approximation that is
2624 guaranteed to be in range. */
2625 long hz_per_ns = (hz / EMACS_TIME_RESOLUTION
2626 + (hz % EMACS_TIME_RESOLUTION != 0));
2627 ns = frac / hz_per_ns;
2628 }
2629
e9a9ae03 2630 return make_emacs_time (s, ns);
06e111a6
DN		 2631}
2632
2633static Lisp_Object
2634ltime_from_jiffies (unsigned long long tval, long hz)
2635{
d35af63c
PE		 2636 EMACS_TIME t = time_from_jiffies (tval, hz);
2637 return make_lisp_time (t);
06e111a6
DN		 2638}
2639
d35af63c
PE		 2640static EMACS_TIME
2641get_up_time (void)
06e111a6
DN		 2642{
2643 FILE *fup;
e9a9ae03 2644 EMACS_TIME up = make_emacs_time (0, 0);
06e111a6 2645
4d7e6e51 2646 block_input ();
06e111a6
DN		 2647 fup = fopen ("/proc/uptime", "r");
2648
2649 if (fup)
2650 {
d35af63c
PE		 2651 unsigned long long upsec, upfrac, idlesec, idlefrac;
2652 int upfrac_start, upfrac_end, idlefrac_start, idlefrac_end;
06e111a6 2653
d35af63c
PE		 2654 if (fscanf (fup, "%llu.%n%llu%n %llu.%n%llu%n",
2655 &upsec, &upfrac_start, &upfrac, &upfrac_end,
2656 &idlesec, &idlefrac_start, &idlefrac, &idlefrac_end)
2657 == 4)
06e111a6 2658 {
d35af63c
PE		 2659 if (TYPE_MAXIMUM (time_t) < upsec)
2660 {
2661 upsec = TYPE_MAXIMUM (time_t);
2662 upfrac = EMACS_TIME_RESOLUTION - 1;
2663 }
2664 else
2665 {
2666 int upfraclen = upfrac_end - upfrac_start;
2667 for (; upfraclen < LOG10_EMACS_TIME_RESOLUTION; upfraclen++)
2668 upfrac *= 10;
2669 for (; LOG10_EMACS_TIME_RESOLUTION < upfraclen; upfraclen--)
2670 upfrac /= 10;
2671 upfrac = min (upfrac, EMACS_TIME_RESOLUTION - 1);
2672 }
e9a9ae03 2673 up = make_emacs_time (upsec, upfrac);
06e111a6
DN		 2674 }
2675 fclose (fup);
2676 }
4d7e6e51 2677 unblock_input ();
d35af63c
PE		 2678
2679 return up;
06e111a6
DN		 2680}
2681
2682#define MAJOR(d) (((unsigned)(d) >> 8) & 0xfff)
2683#define MINOR(d) (((unsigned)(d) & 0xff) | (((unsigned)(d) & 0xfff00000) >> 12))
2684
2685static Lisp_Object
f4f634e8 2686procfs_ttyname (int rdev)
06e111a6
DN		 2687{
2688 FILE *fdev = NULL;
2689 char name[PATH_MAX];
2690
4d7e6e51 2691 block_input ();
06e111a6
DN		 2692 fdev = fopen ("/proc/tty/drivers", "r");
2693
2694 if (fdev)
2695 {
2696 unsigned major;
2697 unsigned long minor_beg, minor_end;
2698 char minor[25]; /* 2 32-bit numbers + dash */
2699 char *endp;
2700
2701 while (!feof (fdev) && !ferror (fdev))
2702 {
2703 if (3 <= fscanf (fdev, "%*s %s %u %s %*s\n", name, &major, minor)
2704 && major == MAJOR (rdev))
2705 {
2706 minor_beg = strtoul (minor, &endp, 0);
2707 if (*endp == '\0')
2708 minor_end = minor_beg;
2709 else if (*endp == '-')
2710 minor_end = strtoul (endp + 1, &endp, 0);
2711 else
2712 continue;
2713
2714 if (MINOR (rdev) >= minor_beg && MINOR (rdev) <= minor_end)
2715 {
10d66ec0 2716 sprintf (name + strlen (name), "%u", MINOR (rdev));
06e111a6
DN		 2717 break;
2718 }
2719 }
2720 }
2721 fclose (fdev);
2722 }
4d7e6e51 2723 unblock_input ();
06e111a6
DN		 2724 return build_string (name);
2725}
2726
2727static unsigned long
2728procfs_get_total_memory (void)
2729{
2730 FILE *fmem = NULL;
2731 unsigned long retval = 2 * 1024 * 1024; /* default: 2GB */
2732
4d7e6e51 2733 block_input ();
06e111a6
DN		 2734 fmem = fopen ("/proc/meminfo", "r");
2735
2736 if (fmem)
2737 {
2738 unsigned long entry_value;
2739 char entry_name[20]; /* the longest I saw is 13+1 */
2740
2741 while (!feof (fmem) && !ferror (fmem))
2742 {
2743 if (2 <= fscanf (fmem, "%s %lu kB\n", entry_name, &entry_value)
2744 && strcmp (entry_name, "MemTotal:") == 0)
2745 {
2746 retval = entry_value;
2747 break;
2748 }
2749 }
2750 fclose (fmem);
2751 }
4d7e6e51 2752 unblock_input ();
06e111a6
DN		 2753 return retval;
2754}
2755
2756Lisp_Object
f4f634e8 2757system_process_attributes (Lisp_Object pid)
06e111a6
DN		 2758{
2759 char procfn[PATH_MAX], fn[PATH_MAX];
2760 struct stat st;
2761 struct passwd *pw;
2762 struct group *gr;
2763 long clocks_per_sec;
2764 char *procfn_end;
2765 char procbuf[1025], *p, *q;
2766 int fd;
2767 ssize_t nread;
e99a530f
PE		 2768 static char const default_cmd[] = "???";
2769 const char *cmd = default_cmd;
2770 int cmdsize = sizeof default_cmd - 1;
06e111a6 2771 char *cmdline = NULL;
e99a530f 2772 ptrdiff_t cmdline_size;
06e111a6 2773 unsigned char c;
d311d28c
PE		 2774 printmax_t proc_id;
2775 int ppid, pgrp, sess, tty, tpgid, thcount;
2776 uid_t uid;
2777 gid_t gid;
a70072c9
PE		 2778 unsigned long long u_time, s_time, cutime, cstime, start;
2779 long priority, niceness, rss;
06e111a6 2780 unsigned long minflt, majflt, cminflt, cmajflt, vsize;
d35af63c 2781 EMACS_TIME tnow, tstart, tboot, telapsed, us_time;
06e111a6
DN		 2782 double pcpu, pmem;
2783 Lisp_Object attrs = Qnil;
2784 Lisp_Object cmd_str, decoded_cmd, tem;
2785 struct gcpro gcpro1, gcpro2;
06e111a6
DN		 2786
2787 CHECK_NUMBER_OR_FLOAT (pid);
225a2cff 2788 CONS_TO_INTEGER (pid, pid_t, proc_id);
d311d28c 2789 sprintf (procfn, "/proc/%"pMd, proc_id);
06e111a6
DN		 2790 if (stat (procfn, &st) < 0)
2791 return attrs;
2792
2793 GCPRO2 (attrs, decoded_cmd);
2794
2795 /* euid egid */
2796 uid = st.st_uid;
d311d28c 2797 attrs = Fcons (Fcons (Qeuid, make_fixnum_or_float (uid)), attrs);
4d7e6e51 2798 block_input ();
06e111a6 2799 pw = getpwuid (uid);
4d7e6e51 2800 unblock_input ();
06e111a6
DN		 2801 if (pw)
2802 attrs = Fcons (Fcons (Quser, build_string (pw->pw_name)), attrs);
2803
2804 gid = st.st_gid;
d311d28c 2805 attrs = Fcons (Fcons (Qegid, make_fixnum_or_float (gid)), attrs);
4d7e6e51 2806 block_input ();
06e111a6 2807 gr = getgrgid (gid);
4d7e6e51 2808 unblock_input ();
06e111a6
DN		 2809 if (gr)
2810 attrs = Fcons (Fcons (Qgroup, build_string (gr->gr_name)), attrs);
2811
2812 strcpy (fn, procfn);
2813 procfn_end = fn + strlen (fn);
2814 strcpy (procfn_end, "/stat");
2815 fd = emacs_open (fn, O_RDONLY, 0);
cf84bb53 2816 if (fd >= 0 && (nread = emacs_read (fd, procbuf, sizeof (procbuf) - 1)) > 0)
06e111a6
DN		 2817 {
2818 procbuf[nread] = '\0';
2819 p = procbuf;
2820
2821 p = strchr (p, '(');
2822 if (p != NULL)
2823 {
2824 q = strrchr (p + 1, ')');
2825 /* comm */
2826 if (q != NULL)
2827 {
2828 cmd = p + 1;
2829 cmdsize = q - cmd;
2830 }
2831 }
2832 else
2833 q = NULL;
06e111a6
DN		 2834 /* Command name is encoded in locale-coding-system; decode it. */
2835 cmd_str = make_unibyte_string (cmd, cmdsize);
2836 decoded_cmd = code_convert_string_norecord (cmd_str,
2837 Vlocale_coding_system, 0);
2838 attrs = Fcons (Fcons (Qcomm, decoded_cmd), attrs);
2839
2840 if (q)
2841 {
2842 EMACS_INT ppid_eint, pgrp_eint, sess_eint, tpgid_eint, thcount_eint;
2843 p = q + 2;
2844 /* state ppid pgrp sess tty tpgid . minflt cminflt majflt cmajflt utime stime cutime cstime priority nice thcount . start vsize rss */
2845 sscanf (p, "%c %d %d %d %d %d %*u %lu %lu %lu %lu %Lu %Lu %Lu %Lu %ld %ld %d %*d %Lu %lu %ld",
2846 &c, &ppid, &pgrp, &sess, &tty, &tpgid,
2847 &minflt, &cminflt, &majflt, &cmajflt,
a70072c9
PE		 2848 &u_time, &s_time, &cutime, &cstime,
2849 &priority, &niceness, &thcount, &start, &vsize, &rss);
06e111a6
DN		 2850 {
2851 char state_str[2];
2852
2853 state_str[0] = c;
2854 state_str[1] = '\0';
2855 tem = build_string (state_str);
2856 attrs = Fcons (Fcons (Qstate, tem), attrs);
2857 }
2858 /* Stops GCC whining about limited range of data type. */
2859 ppid_eint = ppid;
2860 pgrp_eint = pgrp;
2861 sess_eint = sess;
2862 tpgid_eint = tpgid;
2863 thcount_eint = thcount;
2864 attrs = Fcons (Fcons (Qppid, make_fixnum_or_float (ppid_eint)), attrs);
2865 attrs = Fcons (Fcons (Qpgrp, make_fixnum_or_float (pgrp_eint)), attrs);
2866 attrs = Fcons (Fcons (Qsess, make_fixnum_or_float (sess_eint)), attrs);
2867 attrs = Fcons (Fcons (Qttname, procfs_ttyname (tty)), attrs);
2868 attrs = Fcons (Fcons (Qtpgid, make_fixnum_or_float (tpgid_eint)), attrs);
2869 attrs = Fcons (Fcons (Qminflt, make_fixnum_or_float (minflt)), attrs);
2870 attrs = Fcons (Fcons (Qmajflt, make_fixnum_or_float (majflt)), attrs);
2871 attrs = Fcons (Fcons (Qcminflt, make_fixnum_or_float (cminflt)), attrs);
2872 attrs = Fcons (Fcons (Qcmajflt, make_fixnum_or_float (cmajflt)), attrs);
2873 clocks_per_sec = sysconf (_SC_CLK_TCK);
2874 if (clocks_per_sec < 0)
2875 clocks_per_sec = 100;
2876 attrs = Fcons (Fcons (Qutime,
a70072c9 2877 ltime_from_jiffies (u_time, clocks_per_sec)),
06e111a6
DN		 2878 attrs);
2879 attrs = Fcons (Fcons (Qstime,
a70072c9 2880 ltime_from_jiffies (s_time, clocks_per_sec)),
06e111a6 2881 attrs);
ac1e4171 2882 attrs = Fcons (Fcons (Qtime,
a70072c9
PE		 2883 ltime_from_jiffies (s_time + u_time,
2884 clocks_per_sec)),
ac1e4171 2885 attrs);
06e111a6
DN		 2886 attrs = Fcons (Fcons (Qcutime,
2887 ltime_from_jiffies (cutime, clocks_per_sec)),
2888 attrs);
2889 attrs = Fcons (Fcons (Qcstime,
2890 ltime_from_jiffies (cstime, clocks_per_sec)),
ac1e4171
EZ		 2891 attrs);
2892 attrs = Fcons (Fcons (Qctime,
2893 ltime_from_jiffies (cstime+cutime, clocks_per_sec)),
06e111a6
DN		 2894 attrs);
2895 attrs = Fcons (Fcons (Qpri, make_number (priority)), attrs);
a70072c9 2896 attrs = Fcons (Fcons (Qnice, make_number (niceness)), attrs);
06e111a6 2897 attrs = Fcons (Fcons (Qthcount, make_fixnum_or_float (thcount_eint)), attrs);
e9a9ae03 2898 tnow = current_emacs_time ();
d35af63c 2899 telapsed = get_up_time ();
e9a9ae03 2900 tboot = sub_emacs_time (tnow, telapsed);
d35af63c 2901 tstart = time_from_jiffies (start, clocks_per_sec);
e9a9ae03 2902 tstart = add_emacs_time (tboot, tstart);
d35af63c 2903 attrs = Fcons (Fcons (Qstart, make_lisp_time (tstart)), attrs);
06e111a6
DN		 2904 attrs = Fcons (Fcons (Qvsize, make_fixnum_or_float (vsize/1024)), attrs);
2905 attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (4*rss)), attrs);
e9a9ae03 2906 telapsed = sub_emacs_time (tnow, tstart);
d35af63c
PE		 2907 attrs = Fcons (Fcons (Qetime, make_lisp_time (telapsed)), attrs);
2908 us_time = time_from_jiffies (u_time + s_time, clocks_per_sec);
2909 pcpu = (EMACS_TIME_TO_DOUBLE (us_time)
2910 / EMACS_TIME_TO_DOUBLE (telapsed));
06e111a6
DN		 2911 if (pcpu > 1.0)
2912 pcpu = 1.0;
2913 attrs = Fcons (Fcons (Qpcpu, make_float (100 * pcpu)), attrs);
2914 pmem = 4.0 * 100 * rss / procfs_get_total_memory ();
2915 if (pmem > 100)
2916 pmem = 100;
2917 attrs = Fcons (Fcons (Qpmem, make_float (pmem)), attrs);
2918 }
2919 }
2920 if (fd >= 0)
2921 emacs_close (fd);
2922
2923 /* args */
2924 strcpy (procfn_end, "/cmdline");
2925 fd = emacs_open (fn, O_RDONLY, 0);
2926 if (fd >= 0)
2927 {
fbd02d7b 2928 char ch;
fe6442b1 2929 for (cmdline_size = 0; cmdline_size < STRING_BYTES_BOUND; cmdline_size++)
06e111a6 2930 {
fe6442b1
PE		 2931 if (emacs_read (fd, &ch, 1) != 1)
2932 break;
fbd02d7b 2933 c = ch;
620f13b0 2934 if (c_isspace (c) || c == '\\')
06e111a6
DN		 2935 cmdline_size++; /* for later quoting, see below */
2936 }
2937 if (cmdline_size)
2938 {
2939 cmdline = xmalloc (cmdline_size + 1);
2940 lseek (fd, 0L, SEEK_SET);
2941 cmdline[0] = '\0';
2942 if ((nread = read (fd, cmdline, cmdline_size)) >= 0)
2943 cmdline[nread++] = '\0';
2944 else
2945 {
2946 /* Assigning zero to `nread' makes us skip the following
2947 two loops, assign zero to cmdline_size, and enter the
2948 following `if' clause that handles unknown command
2949 lines. */
2950 nread = 0;
2951 }
2952 /* We don't want trailing null characters. */
fe6442b1 2953 for (p = cmdline + nread; p > cmdline + 1 && !p[-1]; p--)
06e111a6
DN		 2954 nread--;
2955 for (p = cmdline; p < cmdline + nread; p++)
2956 {
2957 /* Escape-quote whitespace and backslashes. */
620f13b0 2958 if (c_isspace (*p) || *p == '\\')
06e111a6
DN		 2959 {
2960 memmove (p + 1, p, nread - (p - cmdline));
2961 nread++;
2962 *p++ = '\\';
2963 }
2964 else if (*p == '\0')
2965 *p = ' ';
2966 }
2967 cmdline_size = nread;
2968 }
2969 if (!cmdline_size)
2970 {
06e111a6
DN		 2971 cmdline_size = cmdsize + 2;
2972 cmdline = xmalloc (cmdline_size + 1);
e99a530f 2973 sprintf (cmdline, "[%.*s]", cmdsize, cmd);
06e111a6
DN		 2974 }
2975 emacs_close (fd);
2976 /* Command line is encoded in locale-coding-system; decode it. */
2977 cmd_str = make_unibyte_string (cmdline, cmdline_size);
2978 decoded_cmd = code_convert_string_norecord (cmd_str,
2979 Vlocale_coding_system, 0);
2980 xfree (cmdline);
2981 attrs = Fcons (Fcons (Qargs, decoded_cmd), attrs);
2982 }
2983
2984 UNGCPRO;
2985 return attrs;
2986}
91c85b70 2987
f4f634e8
DN		 2988#elif defined (SOLARIS2) && defined (HAVE_PROCFS)
2989
2990/* The <procfs.h> header does not like to be included if _LP64 is defined and
2991 __FILE_OFFSET_BITS == 64. This is an ugly workaround that. */
2992#if !defined (_LP64) && defined (_FILE_OFFSET_BITS) && (_FILE_OFFSET_BITS == 64)
2993#define PROCFS_FILE_OFFSET_BITS_HACK 1
2994#undef _FILE_OFFSET_BITS
2995#else
2996#define PROCFS_FILE_OFFSET_BITS_HACK 0
2997#endif
2998
2999#include <procfs.h>
3000
3001#if PROCFS_FILE_OFFSET_BITS_HACK == 1
3002#define _FILE_OFFSET_BITS 64
90efadd1
PE		 3003#ifdef _FILE_OFFSET_BITS /* Avoid unused-macro warnings. */
3004#endif
f4f634e8
DN		 3005#endif /* PROCFS_FILE_OFFSET_BITS_HACK == 1 */
3006
3007Lisp_Object
3008system_process_attributes (Lisp_Object pid)
3009{
3010 char procfn[PATH_MAX], fn[PATH_MAX];
3011 struct stat st;
3012 struct passwd *pw;
3013 struct group *gr;
3014 char *procfn_end;
3015 struct psinfo pinfo;
3016 int fd;
3017 ssize_t nread;
d311d28c
PE		 3018 printmax_t proc_id;
3019 uid_t uid;
3020 gid_t gid;
f4f634e8
DN		 3021 Lisp_Object attrs = Qnil;
3022 Lisp_Object decoded_cmd, tem;
3023 struct gcpro gcpro1, gcpro2;
f4f634e8
DN		 3024
3025 CHECK_NUMBER_OR_FLOAT (pid);
225a2cff 3026 CONS_TO_INTEGER (pid, pid_t, proc_id);
d311d28c 3027 sprintf (procfn, "/proc/%"pMd, proc_id);
f4f634e8
DN		 3028 if (stat (procfn, &st) < 0)
3029 return attrs;
3030
3031 GCPRO2 (attrs, decoded_cmd);
3032
3033 /* euid egid */
3034 uid = st.st_uid;
d311d28c 3035 attrs = Fcons (Fcons (Qeuid, make_fixnum_or_float (uid)), attrs);
4d7e6e51 3036 block_input ();
f4f634e8 3037 pw = getpwuid (uid);
4d7e6e51 3038 unblock_input ();
f4f634e8
DN		 3039 if (pw)
3040 attrs = Fcons (Fcons (Quser, build_string (pw->pw_name)), attrs);
3041
3042 gid = st.st_gid;
d311d28c 3043 attrs = Fcons (Fcons (Qegid, make_fixnum_or_float (gid)), attrs);
4d7e6e51 3044 block_input ();
f4f634e8 3045 gr = getgrgid (gid);
4d7e6e51 3046 unblock_input ();
f4f634e8
DN		 3047 if (gr)
3048 attrs = Fcons (Fcons (Qgroup, build_string (gr->gr_name)), attrs);
3049
3050 strcpy (fn, procfn);
3051 procfn_end = fn + strlen (fn);
3052 strcpy (procfn_end, "/psinfo");
3053 fd = emacs_open (fn, O_RDONLY, 0);
3054 if (fd >= 0
cf84bb53 3055 && (nread = read (fd, (char*)&pinfo, sizeof (struct psinfo)) > 0))
f4f634e8
DN		 3056 {
3057 attrs = Fcons (Fcons (Qppid, make_fixnum_or_float (pinfo.pr_ppid)), attrs);
3058 attrs = Fcons (Fcons (Qpgrp, make_fixnum_or_float (pinfo.pr_pgid)), attrs);
3059 attrs = Fcons (Fcons (Qsess, make_fixnum_or_float (pinfo.pr_sid)), attrs);
3060
3061 {
3062 char state_str[2];
3063 state_str[0] = pinfo.pr_lwp.pr_sname;
3064 state_str[1] = '\0';
3065 tem = build_string (state_str);
3066 attrs = Fcons (Fcons (Qstate, tem), attrs);
3067 }
3068
3069 /* FIXME: missing Qttyname. psinfo.pr_ttydev is a dev_t,
3070 need to get a string from it. */
3071
3072 /* FIXME: missing: Qtpgid */
3073
3074 /* FIXME: missing:
3075 Qminflt
3076 Qmajflt
3077 Qcminflt
3078 Qcmajflt
3079
bfe11752
DN		 3080 Qutime
3081 Qcutime
f4f634e8
DN		 3082 Qstime
3083 Qcstime
3084 Are they available? */
3085
d35af63c
PE		 3086 attrs = Fcons (Fcons (Qtime, make_lisp_time (pinfo.pr_time)), attrs);
3087 attrs = Fcons (Fcons (Qctime, make_lisp_time (pinfo.pr_ctime)), attrs);
f4f634e8
DN		 3088 attrs = Fcons (Fcons (Qpri, make_number (pinfo.pr_lwp.pr_pri)), attrs);
3089 attrs = Fcons (Fcons (Qnice, make_number (pinfo.pr_lwp.pr_nice)), attrs);
3090 attrs = Fcons (Fcons (Qthcount, make_fixnum_or_float (pinfo.pr_nlwp)), attrs);
3091
d35af63c 3092 attrs = Fcons (Fcons (Qstart, make_lisp_time (pinfo.pr_start)), attrs);
f4f634e8
DN		 3093 attrs = Fcons (Fcons (Qvsize, make_fixnum_or_float (pinfo.pr_size)), attrs);
3094 attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (pinfo.pr_rssize)), attrs);
3095
773d47f6
PE		 3096 /* pr_pctcpu and pr_pctmem are unsigned integers in the
3097 range 0 .. 2**15, representing 0.0 .. 1.0. */
63810350
PE		 3098 attrs = Fcons (Fcons (Qpcpu, make_float (100.0 / 0x8000 * pinfo.pr_pctcpu)), attrs);
3099 attrs = Fcons (Fcons (Qpmem, make_float (100.0 / 0x8000 * pinfo.pr_pctmem)), attrs);
f4f634e8
DN		 3100
3101 decoded_cmd
3102 = code_convert_string_norecord (make_unibyte_string (pinfo.pr_fname,
3103 strlen (pinfo.pr_fname)),
3104 Vlocale_coding_system, 0);
3105 attrs = Fcons (Fcons (Qcomm, decoded_cmd), attrs);
3106 decoded_cmd
3107 = code_convert_string_norecord (make_unibyte_string (pinfo.pr_psargs,
3108 strlen (pinfo.pr_psargs)),
3109 Vlocale_coding_system, 0);
3110 attrs = Fcons (Fcons (Qargs, decoded_cmd), attrs);
3111 }
3112
2d2d05d8
DN		 3113 if (fd >= 0)
3114 emacs_close (fd);
3115
f4f634e8
DN		 3116 UNGCPRO;
3117 return attrs;
3118}
06e111a6 3119
5790543d 3120#elif defined __FreeBSD__
b91b7e4d 3121
d054f3fb
PE		 3122static EMACS_TIME
3123timeval_to_EMACS_TIME (struct timeval t)
3124{
e9a9ae03 3125 return make_emacs_time (t.tv_sec, t.tv_usec * 1000);
d054f3fb
PE		 3126}
3127
3128static Lisp_Object
db7b8d06 3129make_lisp_timeval (struct timeval t)
d054f3fb
PE		 3130{
3131 return make_lisp_time (timeval_to_EMACS_TIME (t));
3132}
3133
b91b7e4d
EW		 3134Lisp_Object
3135system_process_attributes (Lisp_Object pid)
3136{
3137 int proc_id;
5790543d 3138 int pagesize = getpagesize ();
b91b7e4d
EW		 3139 int npages;
3140 int fscale;
3141 struct passwd *pw;
3142 struct group *gr;
3143 char *ttyname;
3144 size_t len;
3145 char args[MAXPATHLEN];
3146 EMACS_TIME t, now;
5790543d 3147
b91b7e4d
EW		 3148 int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID};
3149 struct kinfo_proc proc;
5790543d 3150 size_t proclen = sizeof proc;
b91b7e4d
EW		 3151
3152 struct gcpro gcpro1, gcpro2;
3153 Lisp_Object attrs = Qnil;
3154 Lisp_Object decoded_comm;
5790543d 3155
b91b7e4d 3156 CHECK_NUMBER_OR_FLOAT (pid);
af52196c 3157 CONS_TO_INTEGER (pid, int, proc_id);
b91b7e4d 3158 mib[3] = proc_id;
5790543d 3159
b91b7e4d
EW		 3160 if (sysctl (mib, 4, &proc, &proclen, NULL, 0) != 0)
3161 return attrs;
3162
3163 GCPRO2 (attrs, decoded_comm);
5790543d
PE		 3164
3165 attrs = Fcons (Fcons (Qeuid, make_fixnum_or_float (proc.ki_uid)), attrs);
3166
4d7e6e51 3167 block_input ();
b91b7e4d 3168 pw = getpwuid (proc.ki_uid);
4d7e6e51 3169 unblock_input ();
b91b7e4d
EW		 3170 if (pw)
3171 attrs = Fcons (Fcons (Quser, build_string (pw->pw_name)), attrs);
3172
5790543d 3173 attrs = Fcons (Fcons (Qegid, make_fixnum_or_float (proc.ki_svgid)), attrs);
b91b7e4d 3174
4d7e6e51 3175 block_input ();
b91b7e4d 3176 gr = getgrgid (proc.ki_svgid);
4d7e6e51 3177 unblock_input ();
b91b7e4d
EW		 3178 if (gr)
3179 attrs = Fcons (Fcons (Qgroup, build_string (gr->gr_name)), attrs);
3180
3181 decoded_comm = code_convert_string_norecord
3182 (make_unibyte_string (proc.ki_comm, strlen (proc.ki_comm)),
3183 Vlocale_coding_system, 0);
5790543d 3184
b91b7e4d
EW		 3185 attrs = Fcons (Fcons (Qcomm, decoded_comm), attrs);
3186 {
3187 char state[2] = {'\0', '\0'};
3188 switch (proc.ki_stat)
3189 {
3190 case SRUN:
3191 state[0] = 'R';
3192 break;
3193
3194 case SSLEEP:
3195 state[0] = 'S';
3196 break;
5790543d 3197
b91b7e4d
EW		 3198 case SLOCK:
3199 state[0] = 'D';
3200 break;
3201
3202 case SZOMB:
3203 state[0] = 'Z';
3204 break;
5790543d 3205
b91b7e4d
EW		 3206 case SSTOP:
3207 state[0] = 'T';
3208 break;
3209 }
3210 attrs = Fcons (Fcons (Qstate, build_string (state)), attrs);
3211 }
5790543d 3212
b91b7e4d
EW		 3213 attrs = Fcons (Fcons (Qppid, make_fixnum_or_float (proc.ki_ppid)), attrs);
3214 attrs = Fcons (Fcons (Qpgrp, make_fixnum_or_float (proc.ki_pgid)), attrs);
3215 attrs = Fcons (Fcons (Qsess, make_fixnum_or_float (proc.ki_sid)), attrs);
3216
4d7e6e51 3217 block_input ();
b91b7e4d 3218 ttyname = proc.ki_tdev == NODEV ? NULL : devname (proc.ki_tdev, S_IFCHR);
4d7e6e51 3219 unblock_input ();
b91b7e4d
EW		 3220 if (ttyname)
3221 attrs = Fcons (Fcons (Qtty, build_string (ttyname)), attrs);
5790543d 3222
b91b7e4d
EW		 3223 attrs = Fcons (Fcons (Qtpgid, make_fixnum_or_float (proc.ki_tpgid)), attrs);
3224 attrs = Fcons (Fcons (Qminflt, make_fixnum_or_float (proc.ki_rusage.ru_minflt)), attrs);
3225 attrs = Fcons (Fcons (Qmajflt, make_fixnum_or_float (proc.ki_rusage.ru_majflt)), attrs);
3226 attrs = Fcons (Fcons (Qcminflt, make_number (proc.ki_rusage_ch.ru_minflt)), attrs);
3227 attrs = Fcons (Fcons (Qcmajflt, make_number (proc.ki_rusage_ch.ru_majflt)), attrs);
3228
db7b8d06
PE		 3229 attrs = Fcons (Fcons (Qutime, make_lisp_timeval (proc.ki_rusage.ru_utime)),
3230 attrs);
3231 attrs = Fcons (Fcons (Qstime, make_lisp_timeval (proc.ki_rusage.ru_stime)),
3232 attrs);
e9a9ae03
PE		 3233 t = add_emacs_time (timeval_to_EMACS_TIME (proc.ki_rusage.ru_utime),
3234 timeval_to_EMACS_TIME (proc.ki_rusage.ru_stime));
db7b8d06 3235 attrs = Fcons (Fcons (Qtime, make_lisp_time (t)), attrs);
b91b7e4d 3236
db7b8d06
PE		 3237 attrs = Fcons (Fcons (Qcutime,
3238 make_lisp_timeval (proc.ki_rusage_ch.ru_utime)),
3239 attrs);
3240 attrs = Fcons (Fcons (Qcstime,
3241 make_lisp_timeval (proc.ki_rusage_ch.ru_utime)),
3242 attrs);
e9a9ae03
PE		 3243 t = add_emacs_time (timeval_to_EMACS_TIME (proc.ki_rusage_ch.ru_utime),
3244 timeval_to_EMACS_TIME (proc.ki_rusage_ch.ru_stime));
db7b8d06 3245 attrs = Fcons (Fcons (Qctime, make_lisp_time (t)), attrs);
b91b7e4d 3246
5790543d
PE		 3247 attrs = Fcons (Fcons (Qthcount, make_fixnum_or_float (proc.ki_numthreads)),
3248 attrs);
b91b7e4d
EW		 3249 attrs = Fcons (Fcons (Qpri, make_number (proc.ki_pri.pri_native)), attrs);
3250 attrs = Fcons (Fcons (Qnice, make_number (proc.ki_nice)), attrs);
db7b8d06 3251 attrs = Fcons (Fcons (Qstart, make_lisp_timeval (proc.ki_start)), attrs);
b91b7e4d 3252 attrs = Fcons (Fcons (Qvsize, make_number (proc.ki_size >> 10)), attrs);
5790543d
PE		 3253 attrs = Fcons (Fcons (Qrss, make_number (proc.ki_rssize * pagesize >> 10)),
3254 attrs);
b91b7e4d 3255
e9a9ae03
PE		 3256 now = current_emacs_time ();
3257 t = sub_emacs_time (now, timeval_to_EMACS_TIME (proc.ki_start));
db7b8d06 3258 attrs = Fcons (Fcons (Qetime, make_lisp_time (t)), attrs);
b91b7e4d 3259
5790543d 3260 len = sizeof fscale;
b91b7e4d
EW		 3261 if (sysctlbyname ("kern.fscale", &fscale, &len, NULL, 0) == 0)
3262 {
5790543d 3263 double pcpu;
b91b7e4d 3264 fixpt_t ccpu;
5790543d 3265 len = sizeof ccpu;
b91b7e4d
EW		 3266 if (sysctlbyname ("kern.ccpu", &ccpu, &len, NULL, 0) == 0)
3267 {
5790543d
PE		 3268 pcpu = (100.0 * proc.ki_pctcpu / fscale
3269 / (1 - exp (proc.ki_swtime * log ((double) ccpu / fscale))));
3270 attrs = Fcons (Fcons (Qpcpu, make_fixnum_or_float (pcpu)), attrs);
b91b7e4d
EW		 3271 }
3272 }
3273
5790543d 3274 len = sizeof npages;
b91b7e4d
EW		 3275 if (sysctlbyname ("hw.availpages", &npages, &len, NULL, 0) == 0)
3276 {
5790543d
PE		 3277 double pmem = (proc.ki_flag & P_INMEM
3278 ? 100.0 * proc.ki_rssize / npages
3279 : 0);
3280 attrs = Fcons (Fcons (Qpmem, make_fixnum_or_float (pmem)), attrs);
b91b7e4d
EW		 3281 }
3282
3283 mib[2] = KERN_PROC_ARGS;
3284 len = MAXPATHLEN;
3285 if (sysctl (mib, 4, args, &len, NULL, 0) == 0)
3286 {
3287 int i;
3288 for (i = 0; i < len; i++)
3289 {
3290 if (! args[i] && i < len - 1)
3291 args[i] = ' ';
3292 }
3293
5790543d
PE		 3294 decoded_comm =
3295 (code_convert_string_norecord
d7ea76b4 3296 (build_unibyte_string (args),
5790543d 3297 Vlocale_coding_system, 0));
b91b7e4d
EW		 3298
3299 attrs = Fcons (Fcons (Qargs, decoded_comm), attrs);
3300 }
5790543d 3301
b91b7e4d
EW		 3302 UNGCPRO;
3303 return attrs;
3304}
3305
f8d23104
DN		 3306/* The WINDOWSNT implementation is in w32.c.
3307 The MSDOS implementation is in dosfns.c. */
c4605e09 3308#elif !defined (WINDOWSNT) && !defined (MSDOS)
06e111a6
DN		 3309
3310Lisp_Object
3311system_process_attributes (Lisp_Object pid)
3312{
9dcbe89b 3313 return Qnil;
06e111a6
DN		 3314}
3315
3316#endif /* !defined (WINDOWSNT) */
Unnamed repository; edit this file 'description' to name the repository.