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