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