HCoop / bpt / emacs.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Add a stub for snprintf, for ancient hosts lacking it.
[bpt/emacs.git] / src / sysdep.c
CommitLineData
86a5659e 1/* Interfaces to system-dependent kernel and library entries.
73b0cd50 2 Copyright (C) 1985-1988, 1993-1995, 1999-2011
8cabe764 3 Free Software Foundation, Inc.
86a5659e
JB		 4
5This file is part of GNU Emacs.
6
9ec0b715 7GNU Emacs is free software: you can redistribute it and/or modify
86a5659e 8it under the terms of the GNU General Public License as published by
9ec0b715
GM		 9the Free Software Foundation, either version 3 of the License, or
10(at your option) any later version.
86a5659e
JB		 11
12GNU Emacs is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
9ec0b715 18along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
86a5659e 19
4838e624 20#include <config.h>
2c55aacf 21#include <ctype.h>
86a5659e 22#include <signal.h>
5890e9f7 23#include <stdio.h>
86a5659e 24#include <setjmp.h>
06e111a6
DN		 25#ifdef HAVE_PWD_H
26#include <pwd.h>
27#include <grp.h>
28#endif /* HAVE_PWD_H */
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 {
300f9fca 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
SM		 435 /* We originally enabled ICANON (and set VEOF to 04), and then had
436 proces.c send additional EOF chars to flush the output when faced
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
JB		 856 struct emacs_tty tty;
857
4ec5cb58
RS		 858 Vtty_erase_char = Qnil;
859
86a5659e
JB		 860 if (noninteractive)
861 return;
862
0b0d3e0b
KL		 863 if (!tty_out->output)
864 return; /* The tty is suspended. */
cf84bb53 865
2246281f
KL		 866 if (! tty_out->old_tty)
867 tty_out->old_tty = (struct emacs_tty *) xmalloc (sizeof (struct emacs_tty));
cf84bb53 868
12e610e8 869 emacs_get_tty (fileno (tty_out->input), tty_out->old_tty);
23dab951 870
2246281f 871 tty = *tty_out->old_tty;
86a5659e 872
a7ebc409 873#if !defined (DOS_NT)
2246281f 874 XSETINT (Vtty_erase_char, tty.main.c_cc[VERASE]);
4ec5cb58 875
2246281f
KL		 876 tty.main.c_iflag |= (IGNBRK); /* Ignore break condition */
877 tty.main.c_iflag &= ~ICRNL; /* Disable map of CR to NL on input */
7f371164
RS		 878#ifdef INLCR /* I'm just being cautious,
879 since I can't check how widespread INLCR is--rms. */
2246281f 880 tty.main.c_iflag &= ~INLCR; /* Disable map of NL to CR on input */
7f371164 881#endif
86a5659e 882#ifdef ISTRIP
2246281f 883 tty.main.c_iflag &= ~ISTRIP; /* don't strip 8th bit on input */
86a5659e 884#endif
2246281f
KL		 885 tty.main.c_lflag &= ~ECHO; /* Disable echo */
886 tty.main.c_lflag &= ~ICANON; /* Disable erase/kill processing */
e2b40c23 887#ifdef IEXTEN
2246281f 888 tty.main.c_lflag &= ~IEXTEN; /* Disable other editing characters. */
e2b40c23 889#endif
2246281f
KL		 890 tty.main.c_lflag |= ISIG; /* Enable signals */
891 if (tty_out->flow_control)
892 {
893 tty.main.c_iflag |= IXON; /* Enable start/stop output control */
86a5659e 894#ifdef IXANY
2246281f 895 tty.main.c_iflag &= ~IXANY;
86a5659e 896#endif /* IXANY */
2246281f
KL		 897 }
898 else
899 tty.main.c_iflag &= ~IXON; /* Disable start/stop output control */
900 tty.main.c_oflag &= ~ONLCR; /* Disable map of NL to CR-NL
901 on output */
902 tty.main.c_oflag &= ~TAB3; /* Disable tab expansion */
86a5659e 903#ifdef CS8
2246281f
KL		 904 if (tty_out->meta_key)
905 {
906 tty.main.c_cflag |= CS8; /* allow 8th bit on input */
907 tty.main.c_cflag &= ~PARENB;/* Don't check parity */
908 }
86a5659e 909#endif
2246281f
KL		 910 if (tty_out->input == stdin)
911 {
912 tty.main.c_cc[VINTR] = quit_char; /* C-g (usually) gives SIGINT */
913 /* Set up C-g for both SIGQUIT and SIGINT.
914 We don't know which we will get, but we handle both alike
915 so which one it really gives us does not matter. */
916 tty.main.c_cc[VQUIT] = quit_char;
917 }
918 else
919 {
920 /* We normally don't get interrupt or quit signals from tty
921 devices other than our controlling terminal; therefore,
922 we must handle C-g as normal input. Unfortunately, this
923 means that the interrupt and quit feature must be
924 disabled on secondary ttys, or we would not even see the
925 keypress.
cf84bb53 926
2246281f
KL		 927 Note that even though emacsclient could have special code
928 to pass SIGINT to Emacs, we should _not_ enable
929 interrupt/quit keys for emacsclient frames. This means
930 that we can't break out of loops in C code from a
931 secondary tty frame, but we can always decide what
932 display the C-g came from, which is more important from a
933 usability point of view. (Consider the case when two
934 people work together using the same Emacs instance.) */
935 tty.main.c_cc[VINTR] = CDISABLE;
936 tty.main.c_cc[VQUIT] = CDISABLE;
937 }
938 tty.main.c_cc[VMIN] = 1; /* Input should wait for at least 1 char */
939 tty.main.c_cc[VTIME] = 0; /* no matter how long that takes. */
86a5659e 940#ifdef VSWTCH
2246281f 941 tty.main.c_cc[VSWTCH] = CDISABLE; /* Turn off shell layering use
91bac16a 942 of C-z */
86a5659e 943#endif /* VSWTCH */
cf84bb53 944
86a5659e 945#ifdef VSUSP
a7ebc409 946 tty.main.c_cc[VSUSP] = CDISABLE; /* Turn off handling of C-z. */
86a5659e
JB		 947#endif /* VSUSP */
948#ifdef V_DSUSP
a7ebc409 949 tty.main.c_cc[V_DSUSP] = CDISABLE; /* Turn off handling of C-y. */
86a5659e 950#endif /* V_DSUSP */
e2b40c23 951#ifdef VDSUSP /* Some systems have VDSUSP, some have V_DSUSP. */
2246281f 952 tty.main.c_cc[VDSUSP] = CDISABLE;
e2b40c23 953#endif /* VDSUSP */
92c995de 954#ifdef VLNEXT
2246281f 955 tty.main.c_cc[VLNEXT] = CDISABLE;
92c995de
RS		 956#endif /* VLNEXT */
957#ifdef VREPRINT
2246281f 958 tty.main.c_cc[VREPRINT] = CDISABLE;
92c995de
RS		 959#endif /* VREPRINT */
960#ifdef VWERASE
2246281f 961 tty.main.c_cc[VWERASE] = CDISABLE;
92c995de
RS		 962#endif /* VWERASE */
963#ifdef VDISCARD
2246281f 964 tty.main.c_cc[VDISCARD] = CDISABLE;
92c995de 965#endif /* VDISCARD */
c179a6d1 966
2246281f
KL		 967 if (tty_out->flow_control)
968 {
421dd92f 969#ifdef VSTART
2246281f 970 tty.main.c_cc[VSTART] = '\021';
421dd92f
RS		 971#endif /* VSTART */
972#ifdef VSTOP
2246281f 973 tty.main.c_cc[VSTOP] = '\023';
421dd92f 974#endif /* VSTOP */
2246281f
KL		 975 }
976 else
977 {
c179a6d1 978#ifdef VSTART
2246281f 979 tty.main.c_cc[VSTART] = CDISABLE;
c179a6d1
RS		 980#endif /* VSTART */
981#ifdef VSTOP
2246281f 982 tty.main.c_cc[VSTOP] = CDISABLE;
c179a6d1 983#endif /* VSTOP */
2246281f 984 }
c179a6d1 985
86a5659e 986#ifdef AIX
f5272227
KL		 987 tty.main.c_cc[VSTRT] = CDISABLE;
988 tty.main.c_cc[VSTOP] = CDISABLE;
989 tty.main.c_cc[VSUSP] = CDISABLE;
990 tty.main.c_cc[VDSUSP] = CDISABLE;
2246281f
KL		 991 if (tty_out->flow_control)
992 {
ac567c95 993#ifdef VSTART
2246281f 994 tty.main.c_cc[VSTART] = '\021';
ac567c95
RS		 995#endif /* VSTART */
996#ifdef VSTOP
2246281f 997 tty.main.c_cc[VSTOP] = '\023';
ac567c95 998#endif /* VSTOP */
2246281f
KL		 999 }
1000 /* Also, PTY overloads NUL and BREAK.
1001 don't ignore break, but don't signal either, so it looks like NUL.
1002 This really serves a purpose only if running in an XTERM window
1003 or via TELNET or the like, but does no harm elsewhere. */
1004 tty.main.c_iflag &= ~IGNBRK;
1005 tty.main.c_iflag &= ~BRKINT;
86a5659e 1006#endif
fe03522b 1007#endif /* not DOS_NT */
cf84bb53 1008
207bdbdb 1009#ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
2246281f
KL		 1010 if (!tty_out->term_initted)
1011 internal_terminal_init ();
4e389d32 1012 dos_ttraw (tty_out);
207bdbdb 1013#endif
91bac16a 1014
12e610e8 1015 emacs_set_tty (fileno (tty_out->input), &tty, 0);
86a5659e 1016
2246281f
KL		 1017 /* This code added to insure that, if flow-control is not to be used,
1018 we have an unlocked terminal at the start. */
91bac16a 1019
86a5659e 1020#ifdef TCXONC
0b0d3e0b 1021 if (!tty_out->flow_control) ioctl (fileno (tty_out->input), TCXONC, 1);
86a5659e 1022#endif
86a5659e 1023#ifdef TIOCSTART
0b0d3e0b 1024 if (!tty_out->flow_control) ioctl (fileno (tty_out->input), TIOCSTART, 0);
86a5659e 1025#endif
86a5659e 1026
a7ebc409 1027#if !defined (DOS_NT)
51417996 1028#ifdef TCOON
0b0d3e0b 1029 if (!tty_out->flow_control) tcflow (fileno (tty_out->input), TCOON);
d228f207 1030#endif
51417996 1031#endif
d228f207 1032
86a5659e 1033#ifdef F_SETFL
eb8c3be9 1034#ifdef F_GETOWN /* F_SETFL does not imply existence of F_GETOWN */
2246281f 1035 if (interrupt_input)
86a5659e 1036 {
0b0d3e0b
KL		 1037 old_fcntl_owner[fileno (tty_out->input)] =
1038 fcntl (fileno (tty_out->input), F_GETOWN, 0);
1039 fcntl (fileno (tty_out->input), F_SETOWN, getpid ());
1040 init_sigio (fileno (tty_out->input));
7e5a23bd 1041#ifdef HAVE_GPM
75a8734b 1042 if (gpm_tty == tty_out)
3e748bcb 1043 {
75a8734b 1044 /* Arrange for mouse events to give us SIGIO signals. */
3e748bcb 1045 fcntl (gpm_fd, F_SETOWN, getpid ());
57669cf1 1046 fcntl (gpm_fd, F_SETFL, fcntl (gpm_fd, F_GETFL, 0) | O_NONBLOCK);
3e748bcb
NR		 1047 init_sigio (gpm_fd);
1048 }
7e5a23bd 1049#endif /* HAVE_GPM */
86a5659e
JB		 1050 }
1051#endif /* F_GETOWN */
1052#endif /* F_SETFL */
1053
86a5659e
JB		 1054#ifdef _IOFBF
1055 /* This symbol is defined on recent USG systems.
1056 Someone says without this call USG won't really buffer the file
1057 even with a call to setbuf. */
0b0d3e0b 1058 setvbuf (tty_out->output, (char *) _sobuf, _IOFBF, sizeof _sobuf);
86a5659e 1059#else
0b0d3e0b 1060 setbuf (tty_out->output, (char *) _sobuf);
86a5659e 1061#endif
4d553a13 1062
69fb5031
JR		 1063 if (tty_out->terminal->set_terminal_modes_hook)
1064 tty_out->terminal->set_terminal_modes_hook (tty_out->terminal);
4b311aaf 1065
9628b887
KL		 1066 if (!tty_out->term_initted)
1067 {
1068 Lisp_Object tail, frame;
1069 FOR_EACH_FRAME (tail, frame)
1070 {
daf01701 1071 /* XXX This needs to be revised. */
9628b887
KL		 1072 if (FRAME_TERMCAP_P (XFRAME (frame))
1073 && FRAME_TTY (XFRAME (frame)) == tty_out)
1074 init_frame_faces (XFRAME (frame));
1075 }
1076 }
045942b2 1077
9628b887 1078 if (tty_out->term_initted && no_redraw_on_reenter)
86a5659e 1079 {
855a0da7
SM		 1080 /* We used to call "direct_output_forward_char(0)" here,
1081 but it's not clear why, since it may not do anything anyway. */
86a5659e
JB		 1082 }
1083 else
1084 {
9628b887 1085 Lisp_Object tail, frame;
0137dbf7 1086 frame_garbaged = 1;
9628b887
KL		 1087 FOR_EACH_FRAME (tail, frame)
1088 {
7ab98847
EZ		 1089 if ((FRAME_TERMCAP_P (XFRAME (frame))
1090 || FRAME_MSDOS_P (XFRAME (frame)))
9628b887
KL		 1091 && FRAME_TTY (XFRAME (frame)) == tty_out)
1092 FRAME_GARBAGED_P (XFRAME (frame)) = 1;
1093 }
86a5659e 1094 }
91bac16a 1095
9628b887 1096 tty_out->term_initted = 1;
86a5659e
JB		 1097}
1098
1099/* Return nonzero if safe to use tabs in output.
1100 At the time this is called, init_sys_modes has not been done yet. */
177c0ea7 1101
dfcf069d 1102int
16c290d8 1103tabs_safe_p (int fd)
86a5659e 1104{
6548cf00 1105 struct emacs_tty etty;
91bac16a 1106
12e610e8
DN		 1107 emacs_get_tty (fd, &etty);
1108#ifndef DOS_NT
1109#ifdef TABDLY
1110 return ((etty.main.c_oflag & TABDLY) != TAB3);
1111#else /* not TABDLY */
1112 return 1;
1113#endif /* not TABDLY */
1114#else /* DOS_NT */
1115 return 0;
1116#endif /* DOS_NT */
86a5659e 1117}
73d5358f 1118\f
86a5659e 1119/* Get terminal size from system.
73d5358f
RS		 1120 Store number of lines into *HEIGHTP and width into *WIDTHP.
1121 We store 0 if there's no valid information. */
86a5659e 1122
08633194 1123void
16c290d8 1124get_tty_size (int fd, int *widthp, int *heightp)
86a5659e 1125{
e16e55d4 1126#if defined TIOCGWINSZ
91bac16a
JB		 1127
1128 /* BSD-style. */
86a5659e 1129 struct winsize size;
91bac16a 1130
16c290d8 1131 if (ioctl (fd, TIOCGWINSZ, &size) == -1)
91bac16a
JB		 1132 *widthp = *heightp = 0;
1133 else
1134 {
1135 *widthp = size.ws_col;
1136 *heightp = size.ws_row;
1137 }
1138
e16e55d4 1139#elif defined TIOCGSIZE
91bac16a
JB		 1140
1141 /* SunOS - style. */
177c0ea7 1142 struct ttysize size;
91bac16a 1143
16c290d8 1144 if (ioctl (fd, TIOCGSIZE, &size) == -1)
91bac16a
JB		 1145 *widthp = *heightp = 0;
1146 else
1147 {
1148 *widthp = size.ts_cols;
1149 *heightp = size.ts_lines;
1150 }
1151
e16e55d4
JB		 1152#elif defined WINDOWSNT
1153
1154 CONSOLE_SCREEN_BUFFER_INFO info;
1155 if (GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &info))
1156 {
1157 *widthp = info.srWindow.Right - info.srWindow.Left + 1;
1158 *heightp = info.srWindow.Bottom - info.srWindow.Top + 1;
1159 }
1160 else
1161 *widthp = *heightp = 0;
1162
1163#elif defined MSDOS
1164
207bdbdb
RS		 1165 *widthp = ScreenCols ();
1166 *heightp = ScreenRows ();
e16e55d4 1167
86a5659e 1168#else /* system doesn't know size */
e16e55d4 1169
86a5659e
JB		 1170 *widthp = 0;
1171 *heightp = 0;
e16e55d4 1172
207bdbdb 1173#endif
86a5659e 1174}
91bac16a 1175
73d5358f
RS		 1176/* Set the logical window size associated with descriptor FD
1177 to HEIGHT and WIDTH. This is used mainly with ptys. */
1178
1179int
971de7fb 1180set_window_size (int fd, int height, int width)
73d5358f
RS		 1181{
1182#ifdef TIOCSWINSZ
1183
1184 /* BSD-style. */
1185 struct winsize size;
1186 size.ws_row = height;
1187 size.ws_col = width;
1188
1189 if (ioctl (fd, TIOCSWINSZ, &size) == -1)
1190 return 0; /* error */
1191 else
1192 return 1;
1193
1194#else
1195#ifdef TIOCSSIZE
1196
1197 /* SunOS - style. */
177c0ea7 1198 struct ttysize size;
73d5358f
RS		 1199 size.ts_lines = height;
1200 size.ts_cols = width;
1201
1202 if (ioctl (fd, TIOCGSIZE, &size) == -1)
1203 return 0;
1204 else
1205 return 1;
1206#else
1207 return -1;
1208#endif /* not SunOS-style */
1209#endif /* not BSD-style */
1210}
1211
86a5659e 1212\f
da8e1115
KL		 1213
1214/* Prepare all terminal devices for exiting Emacs. */
1215
28d440ab
KL		 1216void
1217reset_all_sys_modes (void)
1218{
28d7d09f 1219 struct tty_display_info *tty;
16c290d8 1220 for (tty = tty_list; tty; tty = tty->next)
28d440ab 1221 reset_sys_modes (tty);
28d440ab
KL		 1222}
1223
0a125897 1224/* Prepare the terminal for closing it; move the cursor to the
0137dbf7 1225 bottom of the frame, turn off interrupt-driven I/O, etc. */
da8e1115 1226
08633194 1227void
971de7fb 1228reset_sys_modes (struct tty_display_info *tty_out)
86a5659e
JB		 1229{
1230 if (noninteractive)
1231 {
1232 fflush (stdout);
1233 return;
1234 }
9628b887 1235 if (!tty_out->term_initted)
86a5659e 1236 return;
da8e1115 1237
0b0d3e0b
KL		 1238 if (!tty_out->output)
1239 return; /* The tty is suspended. */
cf84bb53 1240
da8e1115
KL		 1241 /* Go to and clear the last line of the terminal. */
1242
0a125897 1243 cmgoto (tty_out, FrameRows (tty_out) - 1, 0);
cf84bb53 1244
da8e1115
KL		 1245 /* Code adapted from tty_clear_end_of_line. */
1246 if (tty_out->TS_clr_line)
1247 {
1248 emacs_tputs (tty_out, tty_out->TS_clr_line, 1, cmputc);
1249 }
1250 else
1251 { /* have to do it the hard way */
1252 int i;
ed8dad6b 1253 tty_turn_off_insert (tty_out);
cf84bb53 1254
da8e1115 1255 for (i = curX (tty_out); i < FrameCols (tty_out) - 1; i++)
0b0d3e0b
KL		 1256 {
1257 fputc (' ', tty_out->output);
1258 }
da8e1115 1259 }
cf84bb53 1260
0a125897 1261 cmgoto (tty_out, FrameRows (tty_out) - 1, 0);
819b8f00 1262 fflush (tty_out->output);
cf84bb53 1263
69fb5031
JR		 1264 if (tty_out->terminal->reset_terminal_modes_hook)
1265 tty_out->terminal->reset_terminal_modes_hook (tty_out->terminal);
2f98e6e3 1266
2a633456 1267#ifdef BSD_SYSTEM
86a5659e 1268 /* Avoid possible loss of output when changing terminal modes. */
0b0d3e0b 1269 fsync (fileno (tty_out->output));
86a5659e 1270#endif
91bac16a 1271
86a5659e 1272#ifdef F_SETFL
eb8c3be9 1273#ifdef F_SETOWN /* F_SETFL does not imply existence of F_SETOWN */
86a5659e
JB		 1274 if (interrupt_input)
1275 {
0b0d3e0b
KL		 1276 reset_sigio (fileno (tty_out->input));
1277 fcntl (fileno (tty_out->input), F_SETOWN,
1278 old_fcntl_owner[fileno (tty_out->input)]);
86a5659e
JB		 1279 }
1280#endif /* F_SETOWN */
a6b00318 1281#ifdef O_NDELAY
0b0d3e0b
KL		 1282 fcntl (fileno (tty_out->input), F_SETFL,
1283 fcntl (fileno (tty_out->input), F_GETFL, 0) & ~O_NDELAY);
a6b00318 1284#endif
86a5659e 1285#endif /* F_SETFL */
91bac16a 1286
fca177d4 1287 if (tty_out->old_tty)
12e610e8 1288 while (emacs_set_tty (fileno (tty_out->input),
fca177d4 1289 tty_out->old_tty, 0) < 0 && errno == EINTR)
7e32a4fb 1290 ;
86a5659e 1291
207bdbdb
RS		 1292#ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida */
1293 dos_ttcooked ();
1294#endif
1295
86a5659e
JB		 1296}
1297\f
1298#ifdef HAVE_PTYS
1299
1300/* Set up the proper status flags for use of a pty. */
1301
08633194 1302void
971de7fb 1303setup_pty (int fd)
86a5659e
JB		 1304{
1305 /* I'm told that TOICREMOTE does not mean control chars
1306 "can't be sent" but rather that they don't have
1307 input-editing or signaling effects.
1308 That should be good, because we have other ways
1309 to do those things in Emacs.
1310 However, telnet mode seems not to work on 4.2.
1311 So TIOCREMOTE is turned off now. */
1312
1313 /* Under hp-ux, if TIOCREMOTE is turned on, some calls
1314 will hang. In particular, the "timeout" feature (which
1315 causes a read to return if there is no data available)
1316 does this. Also it is known that telnet mode will hang
1317 in such a way that Emacs must be stopped (perhaps this
1318 is the same problem).
177c0ea7 1319
86a5659e
JB		 1320 If TIOCREMOTE is turned off, then there is a bug in
1321 hp-ux which sometimes loses data. Apparently the
1322 code which blocks the master process when the internal
1323 buffer fills up does not work. Other than this,
1324 though, everything else seems to work fine.
177c0ea7 1325
86a5659e
JB		 1326 Since the latter lossage is more benign, we may as well
1327 lose that way. -- cph */
1328#ifdef FIONBIO
bdee2ef3 1329#if defined(UNIX98_PTYS)
86a5659e
JB		 1330 {
1331 int on = 1;
1332 ioctl (fd, FIONBIO, &on);
1333 }
1334#endif
1335#endif
86a5659e
JB		 1336}
1337#endif /* HAVE_PTYS */
1338\f
f8a80313
RS		 1339#ifdef HAVE_SOCKETS
1340#include <sys/socket.h>
1341#include <netdb.h>
1342#endif /* HAVE_SOCKETS */
f8a80313 1343
8581cd64
KH		 1344#ifdef TRY_AGAIN
1345#ifndef HAVE_H_ERRNO
1346extern int h_errno;
1347#endif
1348#endif /* TRY_AGAIN */
1349
c0c86835 1350void
971de7fb 1351init_system_name (void)
86a5659e 1352{
210b2b4f 1353#ifndef HAVE_GETHOSTNAME
c0c86835
KH		 1354 struct utsname uts;
1355 uname (&uts);
1356 Vsystem_name = build_string (uts.nodename);
67004ffb 1357#else /* HAVE_GETHOSTNAME */
cc6e7269 1358 unsigned int hostname_size = 256;
c0c86835
KH		 1359 char *hostname = (char *) alloca (hostname_size);
1360
1361 /* Try to get the host name; if the buffer is too short, try
1362 again. Apparently, the only indication gethostname gives of
1363 whether the buffer was large enough is the presence or absence
1364 of a '\0' in the string. Eech. */
1365 for (;;)
1366 {
1367 gethostname (hostname, hostname_size - 1);
1368 hostname[hostname_size - 1] = '\0';
1369
1370 /* Was the buffer large enough for the '\0'? */
1371 if (strlen (hostname) < hostname_size - 1)
1372 break;
1373
1374 hostname_size <<= 1;
1375 hostname = (char *) alloca (hostname_size);
1376 }
67004ffb 1377#ifdef HAVE_SOCKETS
c0c86835
KH		 1378 /* Turn the hostname into the official, fully-qualified hostname.
1379 Don't do this if we're going to dump; this can confuse system
1380 libraries on some machines and make the dumped emacs core dump. */
67004ffb 1381#ifndef CANNOT_DUMP
c0c86835 1382 if (initialized)
67004ffb 1383#endif /* not CANNOT_DUMP */
8966b757 1384 if (! strchr (hostname, '.'))
960d894c 1385 {
960d894c 1386 int count;
3d66b985
JD		 1387#ifdef HAVE_GETADDRINFO
1388 struct addrinfo *res;
1389 struct addrinfo hints;
1390 int ret;
1391
cf84bb53 1392 memset (&hints, 0, sizeof (hints));
3d66b985
JD		 1393 hints.ai_socktype = SOCK_STREAM;
1394 hints.ai_flags = AI_CANONNAME;
1395
960d894c
KH		 1396 for (count = 0;; count++)
1397 {
3d66b985
JD		 1398 if ((ret = getaddrinfo (hostname, NULL, &hints, &res)) == 0
1399 || ret != EAI_AGAIN)
1400 break;
1401
1402 if (count >= 5)
1403 break;
1404 Fsleep_for (make_number (1), Qnil);
1405 }
1406
1407 if (ret == 0)
1408 {
1409 struct addrinfo *it = res;
1410 while (it)
1411 {
1412 char *fqdn = it->ai_canonname;
8966b757 1413 if (fqdn && strchr (fqdn, '.')
3d66b985
JD		 1414 && strcmp (fqdn, "localhost.localdomain") != 0)
1415 break;
1416 it = it->ai_next;
1417 }
1418 if (it)
1419 {
1420 hostname = alloca (strlen (it->ai_canonname) + 1);
1421 strcpy (hostname, it->ai_canonname);
1422 }
1423 freeaddrinfo (res);
1424 }
1425#else /* !HAVE_GETADDRINFO */
1426 struct hostent *hp;
1427 for (count = 0;; count++)
1428 {
1429
e24f1d55 1430#ifdef TRY_AGAIN
960d894c 1431 h_errno = 0;
e24f1d55 1432#endif
960d894c 1433 hp = gethostbyname (hostname);
efa04277 1434#ifdef TRY_AGAIN
960d894c
KH		 1435 if (! (hp == 0 && h_errno == TRY_AGAIN))
1436#endif
3d66b985 1437
960d894c 1438 break;
3d66b985 1439
960d894c
KH		 1440 if (count >= 5)
1441 break;
1442 Fsleep_for (make_number (1), Qnil);
1443 }
3d66b985 1444
960d894c
KH		 1445 if (hp)
1446 {
1447 char *fqdn = (char *) hp->h_name;
960d894c 1448
8966b757 1449 if (!strchr (fqdn, '.'))
960d894c
KH		 1450 {
1451 /* We still don't have a fully qualified domain name.
1452 Try to find one in the list of alternate names */
1453 char **alias = hp->h_aliases;
923721f4 1454 while (*alias
8966b757 1455 && (!strchr (*alias, '.')
923721f4 1456 || !strcmp (*alias, "localhost.localdomain")))
960d894c
KH		 1457 alias++;
1458 if (*alias)
1459 fqdn = *alias;
1460 }
1461 hostname = fqdn;
960d894c 1462 }
3d66b985 1463#endif /* !HAVE_GETADDRINFO */
960d894c 1464 }
67004ffb 1465#endif /* HAVE_SOCKETS */
c0c86835 1466 Vsystem_name = build_string (hostname);
67004ffb 1467#endif /* HAVE_GETHOSTNAME */
c0c86835
KH		 1468 {
1469 unsigned char *p;
d5db4077 1470 for (p = SDATA (Vsystem_name); *p; p++)
c0c86835
KH		 1471 if (*p == ' ' || *p == '\t')
1472 *p = '-';
1473 }
67004ffb 1474}
86a5659e 1475\f
86a5659e
JB		 1476/* POSIX signals support - DJB */
1477/* Anyone with POSIX signals should have ANSI C declarations */
1478
1fa53021 1479sigset_t empty_mask;
86a5659e 1480
d6dae14b
EZ		 1481#ifndef WINDOWSNT
1482
86a5659e
JB		 1483signal_handler_t
1484sys_signal (int signal_number, signal_handler_t action)
1485{
c639b0e3 1486 struct sigaction new_action, old_action;
86a5659e 1487 sigemptyset (&new_action.sa_mask);
e5c99298 1488 new_action.sa_handler = action;
ef874e3d
AS		 1489 new_action.sa_flags = 0;
1490#if defined (SA_RESTART)
25ab68af 1491 /* Emacs mostly works better with restartable system services. If this
55fafcf0
RS		 1492 flag exists, we probably want to turn it on here.
1493 However, on some systems this resets the timeout of `select'
1494 which means that `select' never finishes if it keeps getting signals.
1495 BROKEN_SA_RESTART is defined on those systems. */
275464e7
SM		 1496 /* It's not clear why the comment above says "mostly works better". --Stef
1497 When SYNC_INPUT is set, we don't want SA_RESTART because we need to poll
1498 for pending input so we need long-running syscalls to be interrupted
1499 after a signal that sets the interrupt_input_pending flag. */
766f52ec
AS		 1500 /* Non-interactive keyboard input goes through stdio, where we always
1501 want restartable system calls. */
ef874e3d
AS		 1502# if defined (BROKEN_SA_RESTART) || defined(SYNC_INPUT)
1503 if (noninteractive)
1504# endif
1505 new_action.sa_flags = SA_RESTART;
25ab68af 1506#endif
d32b2f3c 1507 sigaction (signal_number, &new_action, &old_action);
e5c99298 1508 return (old_action.sa_handler);
86a5659e
JB		 1509}
1510
d6dae14b
EZ		 1511#endif /* WINDOWSNT */
1512
e065a56e
JB		 1513#ifndef __GNUC__
1514/* If we're compiling with GCC, we don't need this function, since it
1515 can be written as a macro. */
1516sigset_t
1517sys_sigmask (int sig)
1518{
1519 sigset_t mask;
1520 sigemptyset (&mask);
1521 sigaddset (&mask, sig);
1522 return mask;
1523}
1524#endif
1525
86a5659e
JB		 1526/* I'd like to have these guys return pointers to the mask storage in here,
1527 but there'd be trouble if the code was saving multiple masks. I'll be
1528 safe and pass the structure. It normally won't be more than 2 bytes
1529 anyhow. - DJB */
1530
1531sigset_t
1532sys_sigblock (sigset_t new_mask)
1533{
1534 sigset_t old_mask;
123403e4 1535 pthread_sigmask (SIG_BLOCK, &new_mask, &old_mask);
86a5659e
JB		 1536 return (old_mask);
1537}
1538
1539sigset_t
1540sys_sigunblock (sigset_t new_mask)
1541{
1542 sigset_t old_mask;
123403e4 1543 pthread_sigmask (SIG_UNBLOCK, &new_mask, &old_mask);
86a5659e
JB		 1544 return (old_mask);
1545}
1546
1547sigset_t
1548sys_sigsetmask (sigset_t new_mask)
1549{
1550 sigset_t old_mask;
123403e4 1551 pthread_sigmask (SIG_SETMASK, &new_mask, &old_mask);
86a5659e
JB		 1552 return (old_mask);
1553}
1554
86a5659e 1555\f
b80263be 1556#if !defined HAVE_STRSIGNAL && !HAVE_DECL_SYS_SIGLIST
ca9c0567
PE		 1557static char *my_sys_siglist[NSIG];
1558# ifdef sys_siglist
1559# undef sys_siglist
1560# endif
1561# define sys_siglist my_sys_siglist
1562#endif
1563
1564void
971de7fb 1565init_signals (void)
ca9c0567 1566{
ca9c0567 1567 sigemptyset (&empty_mask);
ca9c0567 1568
b80263be 1569#if !defined HAVE_STRSIGNAL && !HAVE_DECL_SYS_SIGLIST
ca9c0567
PE		 1570 if (! initialized)
1571 {
1572# ifdef SIGABRT
1573 sys_siglist[SIGABRT] = "Aborted";
1574# endif
1575# ifdef SIGAIO
1576 sys_siglist[SIGAIO] = "LAN I/O interrupt";
1577# endif
1578# ifdef SIGALRM
1579 sys_siglist[SIGALRM] = "Alarm clock";
1580# endif
1581# ifdef SIGBUS
1582 sys_siglist[SIGBUS] = "Bus error";
1583# endif
1584# ifdef SIGCLD
1585 sys_siglist[SIGCLD] = "Child status changed";
1586# endif
1587# ifdef SIGCHLD
1588 sys_siglist[SIGCHLD] = "Child status changed";
1589# endif
1590# ifdef SIGCONT
1591 sys_siglist[SIGCONT] = "Continued";
1592# endif
1593# ifdef SIGDANGER
1594 sys_siglist[SIGDANGER] = "Swap space dangerously low";
1595# endif
1596# ifdef SIGDGNOTIFY
1597 sys_siglist[SIGDGNOTIFY] = "Notification message in queue";
1598# endif
1599# ifdef SIGEMT
1600 sys_siglist[SIGEMT] = "Emulation trap";
1601# endif
1602# ifdef SIGFPE
1603 sys_siglist[SIGFPE] = "Arithmetic exception";
1604# endif
1605# ifdef SIGFREEZE
1606 sys_siglist[SIGFREEZE] = "SIGFREEZE";
1607# endif
1608# ifdef SIGGRANT
1609 sys_siglist[SIGGRANT] = "Monitor mode granted";
1610# endif
1611# ifdef SIGHUP
1612 sys_siglist[SIGHUP] = "Hangup";
1613# endif
1614# ifdef SIGILL
1615 sys_siglist[SIGILL] = "Illegal instruction";
1616# endif
1617# ifdef SIGINT
1618 sys_siglist[SIGINT] = "Interrupt";
1619# endif
1620# ifdef SIGIO
1621 sys_siglist[SIGIO] = "I/O possible";
1622# endif
1623# ifdef SIGIOINT
1624 sys_siglist[SIGIOINT] = "I/O intervention required";
1625# endif
1626# ifdef SIGIOT
1627 sys_siglist[SIGIOT] = "IOT trap";
1628# endif
1629# ifdef SIGKILL
1630 sys_siglist[SIGKILL] = "Killed";
1631# endif
1632# ifdef SIGLOST
1633 sys_siglist[SIGLOST] = "Resource lost";
1634# endif
1635# ifdef SIGLWP
1636 sys_siglist[SIGLWP] = "SIGLWP";
1637# endif
1638# ifdef SIGMSG
1639 sys_siglist[SIGMSG] = "Monitor mode data available";
1640# endif
1641# ifdef SIGPHONE
1642 sys_siglist[SIGWIND] = "SIGPHONE";
1643# endif
1644# ifdef SIGPIPE
1645 sys_siglist[SIGPIPE] = "Broken pipe";
1646# endif
1647# ifdef SIGPOLL
1648 sys_siglist[SIGPOLL] = "Pollable event occurred";
1649# endif
1650# ifdef SIGPROF
1651 sys_siglist[SIGPROF] = "Profiling timer expired";
1652# endif
1653# ifdef SIGPTY
1654 sys_siglist[SIGPTY] = "PTY I/O interrupt";
1655# endif
1656# ifdef SIGPWR
1657 sys_siglist[SIGPWR] = "Power-fail restart";
1658# endif
1659# ifdef SIGQUIT
1660 sys_siglist[SIGQUIT] = "Quit";
1661# endif
1662# ifdef SIGRETRACT
1663 sys_siglist[SIGRETRACT] = "Need to relinguish monitor mode";
1664# endif
1665# ifdef SIGSAK
1666 sys_siglist[SIGSAK] = "Secure attention";
1667# endif
1668# ifdef SIGSEGV
1669 sys_siglist[SIGSEGV] = "Segmentation violation";
1670# endif
1671# ifdef SIGSOUND
1672 sys_siglist[SIGSOUND] = "Sound completed";
1673# endif
1674# ifdef SIGSTOP
1675 sys_siglist[SIGSTOP] = "Stopped (signal)";
1676# endif
1677# ifdef SIGSTP
1678 sys_siglist[SIGSTP] = "Stopped (user)";
1679# endif
1680# ifdef SIGSYS
1681 sys_siglist[SIGSYS] = "Bad argument to system call";
1682# endif
1683# ifdef SIGTERM
1684 sys_siglist[SIGTERM] = "Terminated";
1685# endif
1686# ifdef SIGTHAW
1687 sys_siglist[SIGTHAW] = "SIGTHAW";
1688# endif
1689# ifdef SIGTRAP
1690 sys_siglist[SIGTRAP] = "Trace/breakpoint trap";
1691# endif
1692# ifdef SIGTSTP
1693 sys_siglist[SIGTSTP] = "Stopped (user)";
1694# endif
1695# ifdef SIGTTIN
1696 sys_siglist[SIGTTIN] = "Stopped (tty input)";
1697# endif
1698# ifdef SIGTTOU
1699 sys_siglist[SIGTTOU] = "Stopped (tty output)";
1700# endif
1701# ifdef SIGURG
1702 sys_siglist[SIGURG] = "Urgent I/O condition";
1703# endif
1704# ifdef SIGUSR1
1705 sys_siglist[SIGUSR1] = "User defined signal 1";
1706# endif
1707# ifdef SIGUSR2
1708 sys_siglist[SIGUSR2] = "User defined signal 2";
1709# endif
1710# ifdef SIGVTALRM
1711 sys_siglist[SIGVTALRM] = "Virtual timer expired";
1712# endif
1713# ifdef SIGWAITING
1714 sys_siglist[SIGWAITING] = "Process's LWPs are blocked";
1715# endif
1716# ifdef SIGWINCH
1717 sys_siglist[SIGWINCH] = "Window size changed";
1718# endif
1719# ifdef SIGWIND
1720 sys_siglist[SIGWIND] = "SIGWIND";
1721# endif
1722# ifdef SIGXCPU
1723 sys_siglist[SIGXCPU] = "CPU time limit exceeded";
1724# endif
1725# ifdef SIGXFSZ
1726 sys_siglist[SIGXFSZ] = "File size limit exceeded";
1727# endif
1728 }
b80263be 1729#endif /* !defined HAVE_STRSIGNAL && !defined HAVE_DECL_SYS_SIGLIST */
ca9c0567
PE		 1730}
1731\f
9927a7b1 1732#ifndef HAVE_RANDOM
4bb8c8b7
KH		 1733#ifdef random
1734#define HAVE_RANDOM
1735#endif
1736#endif
1737
1738/* Figure out how many bits the system's random number generator uses.
1739 `random' and `lrand48' are assumed to return 31 usable bits.
1740 BSD `rand' returns a 31 bit value but the low order bits are unusable;
1741 so we'll shift it and treat it like the 15-bit USG `rand'. */
1742
1743#ifndef RAND_BITS
1744# ifdef HAVE_RANDOM
1745# define RAND_BITS 31
1746# else /* !HAVE_RANDOM */
1747# ifdef HAVE_LRAND48
1748# define RAND_BITS 31
1749# define random lrand48
1750# else /* !HAVE_LRAND48 */
1751# define RAND_BITS 15
1752# if RAND_MAX == 32767
1753# define random rand
1754# else /* RAND_MAX != 32767 */
1755# if RAND_MAX == 2147483647
1756# define random() (rand () >> 16)
1757# else /* RAND_MAX != 2147483647 */
1758# ifdef USG
1759# define random rand
1760# else
1761# define random() (rand () >> 16)
2a633456 1762# endif /* !USG */
4bb8c8b7
KH		 1763# endif /* RAND_MAX != 2147483647 */
1764# endif /* RAND_MAX != 32767 */
1765# endif /* !HAVE_LRAND48 */
1766# endif /* !HAVE_RANDOM */
1767#endif /* !RAND_BITS */
2e46c7c6 1768
4bb8c8b7 1769void
971de7fb 1770seed_random (long int arg)
86a5659e 1771{
4bb8c8b7
KH		 1772#ifdef HAVE_RANDOM
1773 srandom ((unsigned int)arg);
f8b53a82 1774#else
4bb8c8b7 1775# ifdef HAVE_LRAND48
76425a49 1776 srand48 (arg);
4bb8c8b7
KH		 1777# else
1778 srand ((unsigned int)arg);
1779# endif
2e46c7c6 1780#endif
86a5659e
JB		 1781}
1782
4bb8c8b7 1783/*
d8ed26bd
PE		 1784 * Return a nonnegative random integer out of whatever we've got.
1785 * It contains enough bits to make a random (signed) Emacs fixnum.
4bb8c8b7
KH		 1786 * This suffices even for a 64-bit architecture with a 15-bit rand.
1787 */
ede49d71 1788EMACS_INT
971de7fb 1789get_random (void)
4bb8c8b7 1790{
ede49d71
PE		 1791 EMACS_UINT val = 0;
1792 int i;
d8ed26bd
PE		 1793 for (i = 0; i < (FIXNUM_BITS + RAND_BITS - 1) / RAND_BITS; i++)
1794 val = (random () ^ (val << RAND_BITS)
1795 ^ (val >> (BITS_PER_EMACS_INT - RAND_BITS)));
1796 val ^= val >> (BITS_PER_EMACS_INT - FIXNUM_BITS);
1797 return val & INTMASK;
4bb8c8b7 1798}
7088d1ca
RM		 1799
1800#ifndef HAVE_STRERROR
fe03522b 1801#ifndef WINDOWSNT
7088d1ca 1802char *
1dae0f0a 1803strerror (int errnum)
7088d1ca
RM		 1804{
1805 extern char *sys_errlist[];
1806 extern int sys_nerr;
1807
1808 if (errnum >= 0 && errnum < sys_nerr)
1809 return sys_errlist[errnum];
1810 return (char *) "Unknown error";
1811}
fe03522b 1812#endif /* not WINDOWSNT */
7088d1ca 1813#endif /* ! HAVE_STRERROR */
55e5faa1
PE		 1814
1815#ifndef HAVE_SNPRINTF
1816/* Approximate snprintf as best we can on ancient hosts that lack it. */
1817int
1818snprintf (char *buf, size_t bufsize, char const *format, ...)
1819{
1820 ptrdiff_t size = min (bufsize, PTRDIFF_MAX);
1821 ptrdiff_t nbytes = size - 1;
1822 va_list ap;
1823
1824 if (size)
1825 {
1826 va_start (ap, format);
1827 nbytes = doprnt (buf, size, format, 0, ap);
1828 va_end (ap);
1829 }
1830
1831 if (nbytes == size - 1)
1832 {
1833 /* Calculate the length of the string that would have been created
1834 had the buffer been large enough. */
1835 char stackbuf[4000];
1836 char *b = stackbuf;
1837 ptrdiff_t bsize = sizeof stackbuf;
1838 va_start (ap, format);
1839 nbytes = evxprintf (&b, &bsize, stackbuf, -1, format, ap);
1840 va_end (ap);
1841 if (b != stackbuf)
1842 xfree (b);
1843 }
1844
1845 if (INT_MAX < nbytes)
1846 {
1847 errno = EOVERFLOW;
1848 return -1;
1849 }
1850 return nbytes;
1851}
1852#endif
86a5659e 1853\f
86a5659e 1854int
971de7fb 1855emacs_open (const char *path, int oflag, int mode)
86a5659e
JB		 1856{
1857 register int rtnval;
68c45bf0 1858
86a5659e 1859 while ((rtnval = open (path, oflag, mode)) == -1
275464e7
SM		 1860 && (errno == EINTR))
1861 QUIT;
86a5659e
JB		 1862 return (rtnval);
1863}
1864
dfcf069d 1865int
971de7fb 1866emacs_close (int fd)
86a5659e 1867{
fe111daf 1868 int did_retry = 0;
86a5659e
JB		 1869 register int rtnval;
1870
1871 while ((rtnval = close (fd)) == -1
fe111daf
KH		 1872 && (errno == EINTR))
1873 did_retry = 1;
1874
1875 /* If close is interrupted SunOS 4.1 may or may not have closed the
1876 file descriptor. If it did the second close will fail with
1877 errno = EBADF. That means we have succeeded. */
1878 if (rtnval == -1 && did_retry && errno == EBADF)
1879 return 0;
1880
86a5659e
JB		 1881 return rtnval;
1882}
1883
1963a2e0
PE		 1884/* Maximum number of bytes to read or write in a single system call.
1885 This works around a serious bug in Linux kernels before 2.6.16; see
1886 <https://bugzilla.redhat.com/show_bug.cgi?format=multiple&id=612839>.
1887 It's likely to work around similar bugs in other operating systems, so do it
1888 on all platforms. Round INT_MAX down to a page size, with the conservative
1889 assumption that page sizes are at most 2**18 bytes (any kernel with a
1890 page size larger than that shouldn't have the bug). */
1891#ifndef MAX_RW_COUNT
1892#define MAX_RW_COUNT (INT_MAX >> 18 << 18)
1893#endif
1894
273a5f82
PE		 1895/* Read from FILEDESC to a buffer BUF with size NBYTE, retrying if interrupted.
1896 Return the number of bytes read, which might be less than NBYTE.
1897 On error, set errno and return -1. */
9587a89d
PE		 1898EMACS_INT
1899emacs_read (int fildes, char *buf, EMACS_INT nbyte)
86a5659e 1900{
8a2cbd72 1901 register ssize_t rtnval;
177c0ea7 1902
71b41406
PE		 1903 /* There is no need to check against MAX_RW_COUNT, since no caller ever
1904 passes a size that large to emacs_read. */
1905
1906 while ((rtnval = read (fildes, buf, nbyte)) == -1
275464e7
SM		 1907 && (errno == EINTR))
1908 QUIT;
86a5659e
JB		 1909 return (rtnval);
1910}
1911
273a5f82
PE		 1912/* Write to FILEDES from a buffer BUF with size NBYTE, retrying if interrupted
1913 or if a partial write occurs. Return the number of bytes written, setting
1914 errno if this is less than NBYTE. */
9587a89d
PE		 1915EMACS_INT
1916emacs_write (int fildes, const char *buf, EMACS_INT nbyte)
86a5659e 1917{
273a5f82 1918 ssize_t rtnval;
9587a89d 1919 EMACS_INT bytes_written;
28272684 1920
b95520f5
BF		 1921 bytes_written = 0;
1922
273a5f82 1923 while (nbyte > 0)
b95520f5 1924 {
1963a2e0 1925 rtnval = write (fildes, buf, min (nbyte, MAX_RW_COUNT));
b95520f5 1926
273a5f82 1927 if (rtnval < 0)
b95520f5
BF		 1928 {
1929 if (errno == EINTR)
77220eeb
SM		 1930 {
1931#ifdef SYNC_INPUT
1932 /* I originally used `QUIT' but that might causes files to
1933 be truncated if you hit C-g in the middle of it. --Stef */
55310b94 1934 process_pending_signals ();
77220eeb
SM		 1935#endif
1936 continue;
1937 }
b95520f5 1938 else
273a5f82 1939 break;
b95520f5
BF		 1940 }
1941
1942 buf += rtnval;
1943 nbyte -= rtnval;
1944 bytes_written += rtnval;
1945 }
273a5f82 1946
b95520f5 1947 return (bytes_written);
86a5659e 1948}
d1fdcab7
PE		 1949
1950static struct allocator const emacs_norealloc_allocator =
1951 { xmalloc, NULL, xfree, memory_full };
1952
1953/* Get the symbolic link value of FILENAME. Return a pointer to a
1954 NUL-terminated string. If readlink fails, return NULL and set
1955 errno. If the value fits in INITIAL_BUF, return INITIAL_BUF.
1956 Otherwise, allocate memory and return a pointer to that memory. If
1957 memory allocation fails, diagnose and fail without returning. If
1958 successful, store the length of the symbolic link into *LINKLEN. */
1959char *
1960emacs_readlink (char const *filename, char initial_buf[READLINK_BUFSIZE])
1961{
1962 return careadlinkat (AT_FDCWD, filename, initial_buf, READLINK_BUFSIZE,
1963 &emacs_norealloc_allocator, careadlinkatcwd);
1964}
86a5659e
JB		 1965\f
1966#ifdef USG
1967/*
1968 * All of the following are for USG.
1969 *
1970 * On USG systems the system calls are INTERRUPTIBLE by signals
1971 * that the user program has elected to catch. Thus the system call
1972 * must be retried in these cases. To handle this without massive
1973 * changes in the source code, we remap the standard system call names
1974 * to names for our own functions in sysdep.c that do the system call
1975 * with retries. Actually, for portability reasons, it is good
1976 * programming practice, as this example shows, to limit all actual
eb8c3be9 1977 * system calls to a single occurrence in the source. Sure, this
86a5659e
JB		 1978 * adds an extra level of function call overhead but it is almost
1979 * always negligible. Fred Fish, Unisoft Systems Inc.
1980 */
1981
86a5659e
JB		 1982/*
1983 * Warning, this function may not duplicate 4.2 action properly
1984 * under error conditions.
1985 */
1986
15dfd3d9
PE		 1987#ifndef HAVE_GETWD
1988
86a5659e
JB		 1989#ifndef MAXPATHLEN
1990/* In 4.1, param.h fails to define this. */
1991#define MAXPATHLEN 1024
1992#endif
1993
86a5659e 1994char *
cf84bb53 1995getwd (char *pathname)
86a5659e
JB		 1996{
1997 char *npath, *spath;
cf84bb53 1998 extern char *getcwd (char *, size_t);
86a5659e 1999
9ac0d9e0 2000 BLOCK_INPUT; /* getcwd uses malloc */
86a5659e 2001 spath = npath = getcwd ((char *) 0, MAXPATHLEN);
f4a7e5bd 2002 if (spath == 0)
18b6bc73
GM		 2003 {
2004 UNBLOCK_INPUT;
2005 return spath;
2006 }
86a5659e
JB		 2007 /* On Altos 3068, getcwd can return @hostname/dir, so discard
2008 up to first slash. Should be harmless on other systems. */
2009 while (*npath && *npath != '/')
2010 npath++;
2011 strcpy (pathname, npath);
2012 free (spath); /* getcwd uses malloc */
9ac0d9e0 2013 UNBLOCK_INPUT;
86a5659e
JB		 2014 return pathname;
2015}
2016
2017#endif /* HAVE_GETWD */
2018
2019/*
2020 * Emulate rename using unlink/link. Note that this is
2021 * only partially correct. Also, doesn't enforce restriction
2022 * that files be of same type (regular->regular, dir->dir, etc).
2023 */
2024
4746118a
JB		 2025#ifndef HAVE_RENAME
2026
cf84bb53
JB		 2027int
2028rename (const char *from, const char *to)
86a5659e
JB		 2029{
2030 if (access (from, 0) == 0)
2031 {
2032 unlink (to);
2033 if (link (from, to) == 0)
2034 if (unlink (from) == 0)
2035 return (0);
2036 }
2037 return (-1);
2038}
2039
4746118a
JB		 2040#endif
2041
86a5659e 2042
69ab3201 2043#if defined(HPUX) && !defined(HAVE_PERROR)
86a5659e
JB		 2044
2045/* HPUX curses library references perror, but as far as we know
2046 it won't be called. Anyway this definition will do for now. */
2047
cf84bb53
JB		 2048void
2049perror (void)
86a5659e
JB		 2050{
2051}
69ab3201 2052#endif /* HPUX and not HAVE_PERROR */
86a5659e 2053
86a5659e
JB		 2054/*
2055 * Gettimeofday. Simulate as much as possible. Only accurate
2056 * to nearest second. Emacs doesn't use tzp so ignore it for now.
2057 * Only needed when subprocesses are defined.
2058 */
2059
86a5659e
JB		 2060#ifndef HAVE_GETTIMEOFDAY
2061#ifdef HAVE_TIMEVAL
177c0ea7 2062
dfcf069d 2063int
cf84bb53 2064gettimeofday (struct timeval *tp, struct timezone *tzp)
86a5659e 2065{
cf84bb53 2066 extern long time (long);
86a5659e 2067
177c0ea7 2068 tp->tv_sec = time ((long *)0);
86a5659e 2069 tp->tv_usec = 0;
4ca7594f
RS		 2070 if (tzp != 0)
2071 tzp->tz_minuteswest = -1;
dfcf069d 2072 return 0;
86a5659e 2073}
177c0ea7 2074
86a5659e 2075#endif
77defa9a 2076#endif /* !HAVE_GETTIMEOFDAY && HAVE_TIMEVAL */
177c0ea7 2077
86a5659e
JB		 2078/*
2079 * This function will go away as soon as all the stubs fixed. (fnf)
2080 */
2081
dfcf069d 2082void
971de7fb 2083croak (char *badfunc)
86a5659e
JB		 2084{
2085 printf ("%s not yet implemented\r\n", badfunc);
28d440ab 2086 reset_all_sys_modes ();
86a5659e
JB		 2087 exit (1);
2088}
2089
2090#endif /* USG */
2091\f
86a5659e
JB		 2092/* Directory routines for systems that don't have them. */
2093
1c97e857 2094#ifdef HAVE_DIRENT_H
86a5659e
JB		 2095
2096#include <dirent.h>
2097
9d9a7716 2098#if !defined (HAVE_CLOSEDIR)
cfdc57af 2099
86a5659e 2100int
9d9a7716 2101closedir (DIR *dirp /* stream from opendir */)
86a5659e 2102{
cfdc57af
RS		 2103 int rtnval;
2104
68c45bf0 2105 rtnval = emacs_close (dirp->dd_fd);
9ac0d9e0 2106 xfree ((char *) dirp);
cfdc57af
RS		 2107
2108 return rtnval;
86a5659e 2109}
9d9a7716 2110#endif /* not HAVE_CLOSEDIR */
1c97e857 2111#endif /* HAVE_DIRENT_H */
86a5659e 2112
23524fb9 2113\f
53ea491a 2114int
e5447b22 2115set_file_times (const char *filename, EMACS_TIME atime, EMACS_TIME mtime)
53ea491a
KH		 2116{
2117#ifdef HAVE_UTIMES
2118 struct timeval tv[2];
2119 tv[0] = atime;
2120 tv[1] = mtime;
8334eb21
RS		 2121 return utimes (filename, tv);
2122#else /* not HAVE_UTIMES */
53ea491a
KH		 2123 struct utimbuf utb;
2124 utb.actime = EMACS_SECS (atime);
2125 utb.modtime = EMACS_SECS (mtime);
8334eb21
RS		 2126 return utime (filename, &utb);
2127#endif /* not HAVE_UTIMES */
53ea491a
KH		 2128}
2129\f
23524fb9
JB		 2130/* mkdir and rmdir functions, for systems which don't have them. */
2131
2132#ifndef HAVE_MKDIR
2133/*
2134 * Written by Robert Rother, Mariah Corporation, August 1985.
2135 *
2136 * If you want it, it's yours. All I ask in return is that if you
2137 * figure out how to do this in a Bourne Shell script you send me
2138 * a copy.
2139 * sdcsvax!rmr or rmr@uscd
2140 *
2141 * Severely hacked over by John Gilmore to make a 4.2BSD compatible
db9cd97a 2142 * subroutine. 11Mar86; hoptoad!gnu
23524fb9
JB		 2143 *
2144 * Modified by rmtodd@uokmax 6-28-87 -- when making an already existing dir,
2145 * subroutine didn't return EEXIST. It does now.
2146 */
2147
2148/*
2149 * Make a directory.
2150 */
2151int
cf84bb53 2152mkdir (char *dpath, int dmode)
23524fb9 2153{
039f26a4 2154 int cpid, status, fd;
23524fb9
JB		 2155 struct stat statbuf;
2156
2157 if (stat (dpath, &statbuf) == 0)
2158 {
2159 errno = EEXIST; /* Stat worked, so it already exists */
2160 return -1;
2161 }
2162
2163 /* If stat fails for a reason other than non-existence, return error */
2164 if (errno != ENOENT)
2165 return -1;
2166
039f26a4 2167 synch_process_alive = 1;
23524fb9
JB		 2168 switch (cpid = fork ())
2169 {
2170
039f26a4 2171 case -1: /* Error in fork */
23524fb9
JB		 2172 return (-1); /* Errno is set already */
2173
2174 case 0: /* Child process */
2175 /*
2176 * Cheap hack to set mode of new directory. Since this
2177 * child process is going away anyway, we zap its umask.
2178 * FIXME, this won't suffice to set SUID, SGID, etc. on this
2179 * directory. Does anybody care?
2180 */
2181 status = umask (0); /* Get current umask */
2182 status = umask (status | (0777 & ~dmode)); /* Set for mkdir */
68c45bf0 2183 fd = emacs_open ("/dev/null", O_RDWR, 0);
039f26a4
RS		 2184 if (fd >= 0)
2185 {
2186 dup2 (fd, 0);
2187 dup2 (fd, 1);
2188 dup2 (fd, 2);
2189 }
23524fb9
JB		 2190 execl ("/bin/mkdir", "mkdir", dpath, (char *) 0);
2191 _exit (-1); /* Can't exec /bin/mkdir */
2192
2193 default: /* Parent process */
039f26a4 2194 wait_for_termination (cpid);
23524fb9
JB		 2195 }
2196
6b0824c9
JD		 2197 if (synch_process_death != 0 || synch_process_retcode != 0
2198 || synch_process_termsig != 0)
23524fb9
JB		 2199 {
2200 errno = EIO; /* We don't know why, but */
2201 return -1; /* /bin/mkdir failed */
2202 }
2203
2204 return 0;
2205}
2206#endif /* not HAVE_MKDIR */
2207
2208#ifndef HAVE_RMDIR
2209int
cf84bb53 2210rmdir (char *dpath)
23524fb9 2211{
039f26a4 2212 int cpid, status, fd;
23524fb9
JB		 2213 struct stat statbuf;
2214
2215 if (stat (dpath, &statbuf) != 0)
2216 {
2217 /* Stat just set errno. We don't have to */
2218 return -1;
2219 }
2220
039f26a4 2221 synch_process_alive = 1;
23524fb9
JB		 2222 switch (cpid = fork ())
2223 {
2224
039f26a4 2225 case -1: /* Error in fork */
23524fb9
JB		 2226 return (-1); /* Errno is set already */
2227
2228 case 0: /* Child process */
68c45bf0 2229 fd = emacs_open ("/dev/null", O_RDWR, 0);
039f26a4
RS		 2230 if (fd >= 0)
2231 {
2232 dup2 (fd, 0);
2233 dup2 (fd, 1);
2234 dup2 (fd, 2);
2235 }
f560db78
RS		 2236 execl ("/bin/rmdir", "rmdir", dpath, (char *) 0);
2237 _exit (-1); /* Can't exec /bin/rmdir */
2238
207bdbdb 2239 default: /* Parent process */
f560db78 2240 wait_for_termination (cpid);
23524fb9
JB		 2241 }
2242
6b0824c9
JD		 2243 if (synch_process_death != 0 || synch_process_retcode != 0
2244 || synch_process_termsig != 0)
23524fb9
JB		 2245 {
2246 errno = EIO; /* We don't know why, but */
f560db78 2247 return -1; /* /bin/rmdir failed */
23524fb9
JB		 2248 }
2249
2250 return 0;
2251}
2252#endif /* !HAVE_RMDIR */
2253
86a5659e 2254\f
68c45bf0
PE		 2255#ifndef HAVE_STRSIGNAL
2256char *
cf84bb53 2257strsignal (int code)
68c45bf0
PE		 2258{
2259 char *signame = 0;
2260
2261 if (0 <= code && code < NSIG)
2262 {
68c45bf0
PE		 2263 /* Cast to suppress warning if the table has const char *. */
2264 signame = (char *) sys_siglist[code];
68c45bf0 2265 }
c4ea52a6 2266
68c45bf0
PE		 2267 return signame;
2268}
2269#endif /* HAVE_STRSIGNAL */
d888760c 2270\f
a7ebc409 2271#ifndef DOS_NT
d888760c 2272/* For make-serial-process */
cf84bb53
JB		 2273int
2274serial_open (char *port)
d888760c
GM		 2275{
2276 int fd = -1;
2277
2278 fd = emacs_open ((char*) port,
2279 O_RDWR
2280#ifdef O_NONBLOCK
2281 | O_NONBLOCK
2282#else
2283 | O_NDELAY
2284#endif
2285#ifdef O_NOCTTY
2286 | O_NOCTTY
2287#endif
2288 , 0);
2289 if (fd < 0)
2290 {
2291 error ("Could not open %s: %s",
2292 port, emacs_strerror (errno));
2293 }
2294#ifdef TIOCEXCL
2295 ioctl (fd, TIOCEXCL, (char *) 0);
2296#endif
2297
2298 return fd;
2299}
759d3f32
SM		 2300
2301#if !defined (HAVE_CFMAKERAW)
2302/* Workaround for targets which are missing cfmakeraw. */
2303/* Pasted from man page. */
cf84bb53
JB		 2304static void
2305cfmakeraw (struct termios *termios_p)
759d3f32
SM		 2306{
2307 termios_p->c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
2308 termios_p->c_oflag &= ~OPOST;
2309 termios_p->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
2310 termios_p->c_cflag &= ~(CSIZE|PARENB);
2311 termios_p->c_cflag |= CS8;
2312}
2313#endif /* !defined (HAVE_CFMAKERAW */
2314
2315#if !defined (HAVE_CFSETSPEED)
2316/* Workaround for targets which are missing cfsetspeed. */
cf84bb53
JB		 2317static int
2318cfsetspeed (struct termios *termios_p, speed_t vitesse)
759d3f32
SM		 2319{
2320 return (cfsetispeed (termios_p, vitesse)
2321 + cfsetospeed (termios_p, vitesse));
2322}
2323#endif
2324
d888760c
GM		 2325/* For serial-process-configure */
2326void
2327serial_configure (struct Lisp_Process *p,
cf84bb53 2328 Lisp_Object contact)
d888760c
GM		 2329{
2330 Lisp_Object childp2 = Qnil;
2331 Lisp_Object tem = Qnil;
2332 struct termios attr;
2333 int err = -1;
2334 char summary[4] = "???"; /* This usually becomes "8N1". */
2335
2336 childp2 = Fcopy_sequence (p->childp);
2337
2338 /* Read port attributes and prepare default configuration. */
2339 err = tcgetattr (p->outfd, &attr);
2340 if (err != 0)
2341 error ("tcgetattr() failed: %s", emacs_strerror (errno));
2342 cfmakeraw (&attr);
2343#if defined (CLOCAL)
2344 attr.c_cflag |= CLOCAL;
2345#endif
2346#if defined (CREAD)
6d1921be 2347 attr.c_cflag |= CREAD;
d888760c
GM		 2348#endif
2349
2350 /* Configure speed. */
2351 if (!NILP (Fplist_member (contact, QCspeed)))
2352 tem = Fplist_get (contact, QCspeed);
2353 else
2354 tem = Fplist_get (p->childp, QCspeed);
2355 CHECK_NUMBER (tem);
2356 err = cfsetspeed (&attr, XINT (tem));
2357 if (err != 0)
c2982e87 2358 error ("cfsetspeed(%"pI"d) failed: %s", XINT (tem),
5fdb398c 2359 emacs_strerror (errno));
d888760c
GM		 2360 childp2 = Fplist_put (childp2, QCspeed, tem);
2361
2362 /* Configure bytesize. */
2363 if (!NILP (Fplist_member (contact, QCbytesize)))
2364 tem = Fplist_get (contact, QCbytesize);
2365 else
2366 tem = Fplist_get (p->childp, QCbytesize);
2367 if (NILP (tem))
2368 tem = make_number (8);
2369 CHECK_NUMBER (tem);
2370 if (XINT (tem) != 7 && XINT (tem) != 8)
2371 error (":bytesize must be nil (8), 7, or 8");
cf84bb53 2372 summary[0] = XINT (tem) + '0';
d888760c
GM		 2373#if defined (CSIZE) && defined (CS7) && defined (CS8)
2374 attr.c_cflag &= ~CSIZE;
2375 attr.c_cflag |= ((XINT (tem) == 7) ? CS7 : CS8);
2376#else
16bad4dd 2377 /* Don't error on bytesize 8, which should be set by cfmakeraw. */
d888760c
GM		 2378 if (XINT (tem) != 8)
2379 error ("Bytesize cannot be changed");
2380#endif
2381 childp2 = Fplist_put (childp2, QCbytesize, tem);
2382
2383 /* Configure parity. */
2384 if (!NILP (Fplist_member (contact, QCparity)))
2385 tem = Fplist_get (contact, QCparity);
2386 else
2387 tem = Fplist_get (p->childp, QCparity);
2388 if (!NILP (tem) && !EQ (tem, Qeven) && !EQ (tem, Qodd))
2389 error (":parity must be nil (no parity), `even', or `odd'");
2390#if defined (PARENB) && defined (PARODD) && defined (IGNPAR) && defined (INPCK)
2391 attr.c_cflag &= ~(PARENB | PARODD);
2392 attr.c_iflag &= ~(IGNPAR | INPCK);
2393 if (NILP (tem))
2394 {
2395 summary[1] = 'N';
2396 }
2397 else if (EQ (tem, Qeven))
2398 {
2399 summary[1] = 'E';
2400 attr.c_cflag |= PARENB;
2401 attr.c_iflag |= (IGNPAR | INPCK);
2402 }
2403 else if (EQ (tem, Qodd))
2404 {
2405 summary[1] = 'O';
2406 attr.c_cflag |= (PARENB | PARODD);
2407 attr.c_iflag |= (IGNPAR | INPCK);
2408 }
2409#else
16bad4dd 2410 /* Don't error on no parity, which should be set by cfmakeraw. */
d888760c
GM		 2411 if (!NILP (tem))
2412 error ("Parity cannot be configured");
2413#endif
2414 childp2 = Fplist_put (childp2, QCparity, tem);
2415
2416 /* Configure stopbits. */
2417 if (!NILP (Fplist_member (contact, QCstopbits)))
2418 tem = Fplist_get (contact, QCstopbits);
2419 else
2420 tem = Fplist_get (p->childp, QCstopbits);
2421 if (NILP (tem))
2422 tem = make_number (1);
2423 CHECK_NUMBER (tem);
2424 if (XINT (tem) != 1 && XINT (tem) != 2)
2425 error (":stopbits must be nil (1 stopbit), 1, or 2");
2426 summary[2] = XINT (tem) + '0';
2427#if defined (CSTOPB)
2428 attr.c_cflag &= ~CSTOPB;
2429 if (XINT (tem) == 2)
2430 attr.c_cflag |= CSTOPB;
2431#else
16bad4dd 2432 /* Don't error on 1 stopbit, which should be set by cfmakeraw. */
d888760c
GM		 2433 if (XINT (tem) != 1)
2434 error ("Stopbits cannot be configured");
2435#endif
2436 childp2 = Fplist_put (childp2, QCstopbits, tem);
2437
2438 /* Configure flowcontrol. */
2439 if (!NILP (Fplist_member (contact, QCflowcontrol)))
2440 tem = Fplist_get (contact, QCflowcontrol);
2441 else
2442 tem = Fplist_get (p->childp, QCflowcontrol);
2443 if (!NILP (tem) && !EQ (tem, Qhw) && !EQ (tem, Qsw))
2444 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
2445#if defined (CRTSCTS)
2446 attr.c_cflag &= ~CRTSCTS;
2447#endif
2448#if defined (CNEW_RTSCTS)
2449 attr.c_cflag &= ~CNEW_RTSCTS;
2450#endif
2451#if defined (IXON) && defined (IXOFF)
2452 attr.c_iflag &= ~(IXON | IXOFF);
2453#endif
2454 if (NILP (tem))
2455 {
2456 /* Already configured. */
2457 }
2458 else if (EQ (tem, Qhw))
2459 {
2460#if defined (CRTSCTS)
2461 attr.c_cflag |= CRTSCTS;
2462#elif defined (CNEW_RTSCTS)
2463 attr.c_cflag |= CNEW_RTSCTS;
2464#else
2465 error ("Hardware flowcontrol (RTS/CTS) not supported");
2466#endif
2467 }
2468 else if (EQ (tem, Qsw))
2469 {
2470#if defined (IXON) && defined (IXOFF)
2471 attr.c_iflag |= (IXON | IXOFF);
2472#else
2473 error ("Software flowcontrol (XON/XOFF) not supported");
2474#endif
2475 }
2476 childp2 = Fplist_put (childp2, QCflowcontrol, tem);
2477
2478 /* Activate configuration. */
2479 err = tcsetattr (p->outfd, TCSANOW, &attr);
2480 if (err != 0)
2481 error ("tcsetattr() failed: %s", emacs_strerror (errno));
2482
2483 childp2 = Fplist_put (childp2, QCsummary, build_string (summary));
2484 p->childp = childp2;
2485
2486}
a7ebc409 2487#endif /* not DOS_NT */
06e111a6
DN		 2488\f
2489/* System depended enumeration of and access to system processes a-la ps(1). */
2490
2491#ifdef HAVE_PROCFS
2492
2493/* Process enumeration and access via /proc. */
2494
2495Lisp_Object
971de7fb 2496list_system_processes (void)
06e111a6
DN		 2497{
2498 Lisp_Object procdir, match, proclist, next;
2499 struct gcpro gcpro1, gcpro2;
2500 register Lisp_Object tail;
2501
2502 GCPRO2 (procdir, match);
2503 /* For every process on the system, there's a directory in the
2504 "/proc" pseudo-directory whose name is the numeric ID of that
2505 process. */
2506 procdir = build_string ("/proc");
2507 match = build_string ("[0-9]+");
2508 proclist = directory_files_internal (procdir, Qnil, match, Qt, 0, Qnil);
2509
2510 /* `proclist' gives process IDs as strings. Destructively convert
2511 each string into a number. */
2512 for (tail = proclist; CONSP (tail); tail = next)
2513 {
2514 next = XCDR (tail);
2515 XSETCAR (tail, Fstring_to_number (XCAR (tail), Qnil));
2516 }
2517 UNGCPRO;
2518
2519 /* directory_files_internal returns the files in reverse order; undo
2520 that. */
2521 proclist = Fnreverse (proclist);
2522 return proclist;
2523}
2524
f8d23104
DN		 2525/* The WINDOWSNT implementation is in w32.c.
2526 The MSDOS implementation is in dosfns.c. */
c4605e09 2527#elif !defined (WINDOWSNT) && !defined (MSDOS)
06e111a6
DN		 2528
2529Lisp_Object
cf84bb53 2530list_system_processes (void)
06e111a6
DN		 2531{
2532 return Qnil;
2533}
91c85b70
EZ		 2534
2535#endif /* !defined (WINDOWSNT) */
06e111a6
DN		 2536
2537#ifdef GNU_LINUX
2538static void
2539time_from_jiffies (unsigned long long tval, long hz,
2540 time_t *sec, unsigned *usec)
2541{
2542 unsigned long long ullsec;
2543
2544 *sec = tval / hz;
2545 ullsec = *sec;
2546 tval -= ullsec * hz;
2547 /* Careful: if HZ > 1 million, then integer division by it yields zero. */
2548 if (hz <= 1000000)
2549 *usec = tval * 1000000 / hz;
2550 else
2551 *usec = tval / (hz / 1000000);
2552}
2553
2554static Lisp_Object
2555ltime_from_jiffies (unsigned long long tval, long hz)
2556{
2557 time_t sec;
2558 unsigned usec;
2559
2560 time_from_jiffies (tval, hz, &sec, &usec);
2561
2562 return list3 (make_number ((sec >> 16) & 0xffff),
2563 make_number (sec & 0xffff),
2564 make_number (usec));
2565}
2566
2567static void
2568get_up_time (time_t *sec, unsigned *usec)
2569{
2570 FILE *fup;
2571
2572 *sec = *usec = 0;
2573
2574 BLOCK_INPUT;
2575 fup = fopen ("/proc/uptime", "r");
2576
2577 if (fup)
2578 {
2579 double uptime, idletime;
2580
2581 /* The numbers in /proc/uptime use C-locale decimal point, but
2582 we already set ourselves to the C locale (see `fixup_locale'
2583 in emacs.c). */
2584 if (2 <= fscanf (fup, "%lf %lf", &uptime, &idletime))
2585 {
2586 *sec = uptime;
2587 *usec = (uptime - *sec) * 1000000;
2588 }
2589 fclose (fup);
2590 }
2591 UNBLOCK_INPUT;
2592}
2593
2594#define MAJOR(d) (((unsigned)(d) >> 8) & 0xfff)
2595#define MINOR(d) (((unsigned)(d) & 0xff) | (((unsigned)(d) & 0xfff00000) >> 12))
2596
2597static Lisp_Object
f4f634e8 2598procfs_ttyname (int rdev)
06e111a6
DN		 2599{
2600 FILE *fdev = NULL;
2601 char name[PATH_MAX];
2602
2603 BLOCK_INPUT;
2604 fdev = fopen ("/proc/tty/drivers", "r");
2605
2606 if (fdev)
2607 {
2608 unsigned major;
2609 unsigned long minor_beg, minor_end;
2610 char minor[25]; /* 2 32-bit numbers + dash */
2611 char *endp;
2612
2613 while (!feof (fdev) && !ferror (fdev))
2614 {
2615 if (3 <= fscanf (fdev, "%*s %s %u %s %*s\n", name, &major, minor)
2616 && major == MAJOR (rdev))
2617 {
2618 minor_beg = strtoul (minor, &endp, 0);
2619 if (*endp == '\0')
2620 minor_end = minor_beg;
2621 else if (*endp == '-')
2622 minor_end = strtoul (endp + 1, &endp, 0);
2623 else
2624 continue;
2625
2626 if (MINOR (rdev) >= minor_beg && MINOR (rdev) <= minor_end)
2627 {
10d66ec0 2628 sprintf (name + strlen (name), "%u", MINOR (rdev));
06e111a6
DN		 2629 break;
2630 }
2631 }
2632 }
2633 fclose (fdev);
2634 }
2635 UNBLOCK_INPUT;
2636 return build_string (name);
2637}
2638
2639static unsigned long
2640procfs_get_total_memory (void)
2641{
2642 FILE *fmem = NULL;
2643 unsigned long retval = 2 * 1024 * 1024; /* default: 2GB */
2644
2645 BLOCK_INPUT;
2646 fmem = fopen ("/proc/meminfo", "r");
2647
2648 if (fmem)
2649 {
2650 unsigned long entry_value;
2651 char entry_name[20]; /* the longest I saw is 13+1 */
2652
2653 while (!feof (fmem) && !ferror (fmem))
2654 {
2655 if (2 <= fscanf (fmem, "%s %lu kB\n", entry_name, &entry_value)
2656 && strcmp (entry_name, "MemTotal:") == 0)
2657 {
2658 retval = entry_value;
2659 break;
2660 }
2661 }
2662 fclose (fmem);
2663 }
2664 UNBLOCK_INPUT;
2665 return retval;
2666}
2667
2668Lisp_Object
f4f634e8 2669system_process_attributes (Lisp_Object pid)
06e111a6
DN		 2670{
2671 char procfn[PATH_MAX], fn[PATH_MAX];
2672 struct stat st;
2673 struct passwd *pw;
2674 struct group *gr;
2675 long clocks_per_sec;
2676 char *procfn_end;
2677 char procbuf[1025], *p, *q;
2678 int fd;
2679 ssize_t nread;
2680 const char *cmd = NULL;
2681 char *cmdline = NULL;
fe6442b1 2682 ptrdiff_t cmdsize = 0, cmdline_size;
06e111a6
DN		 2683 unsigned char c;
2684 int proc_id, ppid, uid, gid, pgrp, sess, tty, tpgid, thcount;
a70072c9
PE		 2685 unsigned long long u_time, s_time, cutime, cstime, start;
2686 long priority, niceness, rss;
06e111a6
DN		 2687 unsigned long minflt, majflt, cminflt, cmajflt, vsize;
2688 time_t sec;
2689 unsigned usec;
2b0a91e7 2690 EMACS_TIME tnow, tstart, tboot, telapsed;
06e111a6
DN		 2691 double pcpu, pmem;
2692 Lisp_Object attrs = Qnil;
2693 Lisp_Object cmd_str, decoded_cmd, tem;
2694 struct gcpro gcpro1, gcpro2;
2695 EMACS_INT uid_eint, gid_eint;
2696
2697 CHECK_NUMBER_OR_FLOAT (pid);
2698 proc_id = FLOATP (pid) ? XFLOAT_DATA (pid) : XINT (pid);
10d66ec0 2699 sprintf (procfn, "/proc/%u", proc_id);
06e111a6
DN		 2700 if (stat (procfn, &st) < 0)
2701 return attrs;
2702
2703 GCPRO2 (attrs, decoded_cmd);
2704
2705 /* euid egid */
2706 uid = st.st_uid;
2707 /* Use of EMACS_INT stops GCC whining about limited range of data type. */
2708 uid_eint = uid;
2709 attrs = Fcons (Fcons (Qeuid, make_fixnum_or_float (uid_eint)), attrs);
2710 BLOCK_INPUT;
2711 pw = getpwuid (uid);
2712 UNBLOCK_INPUT;
2713 if (pw)
2714 attrs = Fcons (Fcons (Quser, build_string (pw->pw_name)), attrs);
2715
2716 gid = st.st_gid;
2717 gid_eint = gid;
2718 attrs = Fcons (Fcons (Qegid, make_fixnum_or_float (gid_eint)), attrs);
2719 BLOCK_INPUT;
2720 gr = getgrgid (gid);
2721 UNBLOCK_INPUT;
2722 if (gr)
2723 attrs = Fcons (Fcons (Qgroup, build_string (gr->gr_name)), attrs);
2724
2725 strcpy (fn, procfn);
2726 procfn_end = fn + strlen (fn);
2727 strcpy (procfn_end, "/stat");
2728 fd = emacs_open (fn, O_RDONLY, 0);
cf84bb53 2729 if (fd >= 0 && (nread = emacs_read (fd, procbuf, sizeof (procbuf) - 1)) > 0)
06e111a6
DN		 2730 {
2731 procbuf[nread] = '\0';
2732 p = procbuf;
2733
2734 p = strchr (p, '(');
2735 if (p != NULL)
2736 {
2737 q = strrchr (p + 1, ')');
2738 /* comm */
2739 if (q != NULL)
2740 {
2741 cmd = p + 1;
2742 cmdsize = q - cmd;
2743 }
2744 }
2745 else
2746 q = NULL;
2747 if (cmd == NULL)
2748 {
2749 cmd = "???";
2750 cmdsize = 3;
2751 }
2752 /* Command name is encoded in locale-coding-system; decode it. */
2753 cmd_str = make_unibyte_string (cmd, cmdsize);
2754 decoded_cmd = code_convert_string_norecord (cmd_str,
2755 Vlocale_coding_system, 0);
2756 attrs = Fcons (Fcons (Qcomm, decoded_cmd), attrs);
2757
2758 if (q)
2759 {
2760 EMACS_INT ppid_eint, pgrp_eint, sess_eint, tpgid_eint, thcount_eint;
2761 p = q + 2;
2762 /* state ppid pgrp sess tty tpgid . minflt cminflt majflt cmajflt utime stime cutime cstime priority nice thcount . start vsize rss */
2763 sscanf (p, "%c %d %d %d %d %d %*u %lu %lu %lu %lu %Lu %Lu %Lu %Lu %ld %ld %d %*d %Lu %lu %ld",
2764 &c, &ppid, &pgrp, &sess, &tty, &tpgid,
2765 &minflt, &cminflt, &majflt, &cmajflt,
a70072c9
PE		 2766 &u_time, &s_time, &cutime, &cstime,
2767 &priority, &niceness, &thcount, &start, &vsize, &rss);
06e111a6
DN		 2768 {
2769 char state_str[2];
2770
2771 state_str[0] = c;
2772 state_str[1] = '\0';
2773 tem = build_string (state_str);
2774 attrs = Fcons (Fcons (Qstate, tem), attrs);
2775 }
2776 /* Stops GCC whining about limited range of data type. */
2777 ppid_eint = ppid;
2778 pgrp_eint = pgrp;
2779 sess_eint = sess;
2780 tpgid_eint = tpgid;
2781 thcount_eint = thcount;
2782 attrs = Fcons (Fcons (Qppid, make_fixnum_or_float (ppid_eint)), attrs);
2783 attrs = Fcons (Fcons (Qpgrp, make_fixnum_or_float (pgrp_eint)), attrs);
2784 attrs = Fcons (Fcons (Qsess, make_fixnum_or_float (sess_eint)), attrs);
2785 attrs = Fcons (Fcons (Qttname, procfs_ttyname (tty)), attrs);
2786 attrs = Fcons (Fcons (Qtpgid, make_fixnum_or_float (tpgid_eint)), attrs);
2787 attrs = Fcons (Fcons (Qminflt, make_fixnum_or_float (minflt)), attrs);
2788 attrs = Fcons (Fcons (Qmajflt, make_fixnum_or_float (majflt)), attrs);
2789 attrs = Fcons (Fcons (Qcminflt, make_fixnum_or_float (cminflt)), attrs);
2790 attrs = Fcons (Fcons (Qcmajflt, make_fixnum_or_float (cmajflt)), attrs);
2791 clocks_per_sec = sysconf (_SC_CLK_TCK);
2792 if (clocks_per_sec < 0)
2793 clocks_per_sec = 100;
2794 attrs = Fcons (Fcons (Qutime,
a70072c9 2795 ltime_from_jiffies (u_time, clocks_per_sec)),
06e111a6
DN		 2796 attrs);
2797 attrs = Fcons (Fcons (Qstime,
a70072c9 2798 ltime_from_jiffies (s_time, clocks_per_sec)),
06e111a6 2799 attrs);
ac1e4171 2800 attrs = Fcons (Fcons (Qtime,
a70072c9
PE		 2801 ltime_from_jiffies (s_time + u_time,
2802 clocks_per_sec)),
ac1e4171 2803 attrs);
06e111a6
DN		 2804 attrs = Fcons (Fcons (Qcutime,
2805 ltime_from_jiffies (cutime, clocks_per_sec)),
2806 attrs);
2807 attrs = Fcons (Fcons (Qcstime,
2808 ltime_from_jiffies (cstime, clocks_per_sec)),
ac1e4171
EZ		 2809 attrs);
2810 attrs = Fcons (Fcons (Qctime,
2811 ltime_from_jiffies (cstime+cutime, clocks_per_sec)),
06e111a6
DN		 2812 attrs);
2813 attrs = Fcons (Fcons (Qpri, make_number (priority)), attrs);
a70072c9 2814 attrs = Fcons (Fcons (Qnice, make_number (niceness)), attrs);
06e111a6
DN		 2815 attrs = Fcons (Fcons (Qthcount, make_fixnum_or_float (thcount_eint)), attrs);
2816 EMACS_GET_TIME (tnow);
2817 get_up_time (&sec, &usec);
2818 EMACS_SET_SECS (telapsed, sec);
2819 EMACS_SET_USECS (telapsed, usec);
2820 EMACS_SUB_TIME (tboot, tnow, telapsed);
2821 time_from_jiffies (start, clocks_per_sec, &sec, &usec);
2822 EMACS_SET_SECS (tstart, sec);
2823 EMACS_SET_USECS (tstart, usec);
2824 EMACS_ADD_TIME (tstart, tboot, tstart);
2825 attrs = Fcons (Fcons (Qstart,
2826 list3 (make_number
2827 ((EMACS_SECS (tstart) >> 16) & 0xffff),
2828 make_number
2829 (EMACS_SECS (tstart) & 0xffff),
2830 make_number
2831 (EMACS_USECS (tstart)))),
2832 attrs);
2833 attrs = Fcons (Fcons (Qvsize, make_fixnum_or_float (vsize/1024)), attrs);
2834 attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (4*rss)), attrs);
2835 EMACS_SUB_TIME (telapsed, tnow, tstart);
2836 attrs = Fcons (Fcons (Qetime,
2837 list3 (make_number
2838 ((EMACS_SECS (telapsed) >> 16) & 0xffff),
2839 make_number
2840 (EMACS_SECS (telapsed) & 0xffff),
2841 make_number
2842 (EMACS_USECS (telapsed)))),
2843 attrs);
a70072c9 2844 time_from_jiffies (u_time + s_time, clocks_per_sec, &sec, &usec);
06e111a6
DN		 2845 pcpu = (sec + usec / 1000000.0) / (EMACS_SECS (telapsed) + EMACS_USECS (telapsed) / 1000000.0);
2846 if (pcpu > 1.0)
2847 pcpu = 1.0;
2848 attrs = Fcons (Fcons (Qpcpu, make_float (100 * pcpu)), attrs);
2849 pmem = 4.0 * 100 * rss / procfs_get_total_memory ();
2850 if (pmem > 100)
2851 pmem = 100;
2852 attrs = Fcons (Fcons (Qpmem, make_float (pmem)), attrs);
2853 }
2854 }
2855 if (fd >= 0)
2856 emacs_close (fd);
2857
2858 /* args */
2859 strcpy (procfn_end, "/cmdline");
2860 fd = emacs_open (fn, O_RDONLY, 0);
2861 if (fd >= 0)
2862 {
fbd02d7b 2863 char ch;
fe6442b1 2864 for (cmdline_size = 0; cmdline_size < STRING_BYTES_BOUND; cmdline_size++)
06e111a6 2865 {
fe6442b1
PE		 2866 if (emacs_read (fd, &ch, 1) != 1)
2867 break;
fbd02d7b 2868 c = ch;
06e111a6
DN		 2869 if (isspace (c) || c == '\\')
2870 cmdline_size++; /* for later quoting, see below */
2871 }
2872 if (cmdline_size)
2873 {
2874 cmdline = xmalloc (cmdline_size + 1);
2875 lseek (fd, 0L, SEEK_SET);
2876 cmdline[0] = '\0';
2877 if ((nread = read (fd, cmdline, cmdline_size)) >= 0)
2878 cmdline[nread++] = '\0';
2879 else
2880 {
2881 /* Assigning zero to `nread' makes us skip the following
2882 two loops, assign zero to cmdline_size, and enter the
2883 following `if' clause that handles unknown command
2884 lines. */
2885 nread = 0;
2886 }
2887 /* We don't want trailing null characters. */
fe6442b1 2888 for (p = cmdline + nread; p > cmdline + 1 && !p[-1]; p--)
06e111a6
DN		 2889 nread--;
2890 for (p = cmdline; p < cmdline + nread; p++)
2891 {
2892 /* Escape-quote whitespace and backslashes. */
2893 if (isspace (*p) || *p == '\\')
2894 {
2895 memmove (p + 1, p, nread - (p - cmdline));
2896 nread++;
2897 *p++ = '\\';
2898 }
2899 else if (*p == '\0')
2900 *p = ' ';
2901 }
2902 cmdline_size = nread;
2903 }
2904 if (!cmdline_size)
2905 {
2906 if (!cmd)
2907 cmd = "???";
2908 if (!cmdsize)
2909 cmdsize = strlen (cmd);
2910 cmdline_size = cmdsize + 2;
2911 cmdline = xmalloc (cmdline_size + 1);
2912 strcpy (cmdline, "[");
2913 strcat (strncat (cmdline, cmd, cmdsize), "]");
2914 }
2915 emacs_close (fd);
2916 /* Command line is encoded in locale-coding-system; decode it. */
2917 cmd_str = make_unibyte_string (cmdline, cmdline_size);
2918 decoded_cmd = code_convert_string_norecord (cmd_str,
2919 Vlocale_coding_system, 0);
2920 xfree (cmdline);
2921 attrs = Fcons (Fcons (Qargs, decoded_cmd), attrs);
2922 }
2923
2924 UNGCPRO;
2925 return attrs;
2926}
91c85b70 2927
f4f634e8
DN		 2928#elif defined (SOLARIS2) && defined (HAVE_PROCFS)
2929
2930/* The <procfs.h> header does not like to be included if _LP64 is defined and
2931 __FILE_OFFSET_BITS == 64. This is an ugly workaround that. */
2932#if !defined (_LP64) && defined (_FILE_OFFSET_BITS) && (_FILE_OFFSET_BITS == 64)
2933#define PROCFS_FILE_OFFSET_BITS_HACK 1
2934#undef _FILE_OFFSET_BITS
2935#else
2936#define PROCFS_FILE_OFFSET_BITS_HACK 0
2937#endif
2938
2939#include <procfs.h>
2940
2941#if PROCFS_FILE_OFFSET_BITS_HACK == 1
2942#define _FILE_OFFSET_BITS 64
90efadd1
PE		 2943#ifdef _FILE_OFFSET_BITS /* Avoid unused-macro warnings. */
2944#endif
f4f634e8
DN		 2945#endif /* PROCFS_FILE_OFFSET_BITS_HACK == 1 */
2946
2947Lisp_Object
2948system_process_attributes (Lisp_Object pid)
2949{
2950 char procfn[PATH_MAX], fn[PATH_MAX];
2951 struct stat st;
2952 struct passwd *pw;
2953 struct group *gr;
2954 char *procfn_end;
2955 struct psinfo pinfo;
2956 int fd;
2957 ssize_t nread;
2958 int proc_id, uid, gid;
2959 Lisp_Object attrs = Qnil;
2960 Lisp_Object decoded_cmd, tem;
2961 struct gcpro gcpro1, gcpro2;
2962 EMACS_INT uid_eint, gid_eint;
2963
2964 CHECK_NUMBER_OR_FLOAT (pid);
2965 proc_id = FLOATP (pid) ? XFLOAT_DATA (pid) : XINT (pid);
2966 sprintf (procfn, "/proc/%u", proc_id);
2967 if (stat (procfn, &st) < 0)
2968 return attrs;
2969
2970 GCPRO2 (attrs, decoded_cmd);
2971
2972 /* euid egid */
2973 uid = st.st_uid;
2974 /* Use of EMACS_INT stops GCC whining about limited range of data type. */
2975 uid_eint = uid;
2976 attrs = Fcons (Fcons (Qeuid, make_fixnum_or_float (uid_eint)), attrs);
2977 BLOCK_INPUT;
2978 pw = getpwuid (uid);
2979 UNBLOCK_INPUT;
2980 if (pw)
2981 attrs = Fcons (Fcons (Quser, build_string (pw->pw_name)), attrs);
2982
2983 gid = st.st_gid;
2984 gid_eint = gid;
2985 attrs = Fcons (Fcons (Qegid, make_fixnum_or_float (gid_eint)), attrs);
2986 BLOCK_INPUT;
2987 gr = getgrgid (gid);
2988 UNBLOCK_INPUT;
2989 if (gr)
2990 attrs = Fcons (Fcons (Qgroup, build_string (gr->gr_name)), attrs);
2991
2992 strcpy (fn, procfn);
2993 procfn_end = fn + strlen (fn);
2994 strcpy (procfn_end, "/psinfo");
2995 fd = emacs_open (fn, O_RDONLY, 0);
2996 if (fd >= 0
cf84bb53 2997 && (nread = read (fd, (char*)&pinfo, sizeof (struct psinfo)) > 0))
f4f634e8
DN		 2998 {
2999 attrs = Fcons (Fcons (Qppid, make_fixnum_or_float (pinfo.pr_ppid)), attrs);
3000 attrs = Fcons (Fcons (Qpgrp, make_fixnum_or_float (pinfo.pr_pgid)), attrs);
3001 attrs = Fcons (Fcons (Qsess, make_fixnum_or_float (pinfo.pr_sid)), attrs);
3002
3003 {
3004 char state_str[2];
3005 state_str[0] = pinfo.pr_lwp.pr_sname;
3006 state_str[1] = '\0';
3007 tem = build_string (state_str);
3008 attrs = Fcons (Fcons (Qstate, tem), attrs);
3009 }
3010
3011 /* FIXME: missing Qttyname. psinfo.pr_ttydev is a dev_t,
3012 need to get a string from it. */
3013
3014 /* FIXME: missing: Qtpgid */
3015
3016 /* FIXME: missing:
3017 Qminflt
3018 Qmajflt
3019 Qcminflt
3020 Qcmajflt
3021
bfe11752
DN		 3022 Qutime
3023 Qcutime
f4f634e8
DN		 3024 Qstime
3025 Qcstime
3026 Are they available? */
3027
bfe11752 3028 attrs = Fcons (Fcons (Qtime,
f4f634e8
DN		 3029 list3 (make_number (pinfo.pr_time.tv_sec >> 16),
3030 make_number (pinfo.pr_time.tv_sec & 0xffff),
3031 make_number (pinfo.pr_time.tv_nsec))),
3032 attrs);
3033
bfe11752 3034 attrs = Fcons (Fcons (Qctime,
f4f634e8
DN		 3035 list3 (make_number (pinfo.pr_ctime.tv_sec >> 16),
3036 make_number (pinfo.pr_ctime.tv_sec & 0xffff),
3037 make_number (pinfo.pr_ctime.tv_nsec))),
3038 attrs);
3039
3040 attrs = Fcons (Fcons (Qpri, make_number (pinfo.pr_lwp.pr_pri)), attrs);
3041 attrs = Fcons (Fcons (Qnice, make_number (pinfo.pr_lwp.pr_nice)), attrs);
3042 attrs = Fcons (Fcons (Qthcount, make_fixnum_or_float (pinfo.pr_nlwp)), attrs);
3043
3044 attrs = Fcons (Fcons (Qstart,
3045 list3 (make_number (pinfo.pr_start.tv_sec >> 16),
3046 make_number (pinfo.pr_start.tv_sec & 0xffff),
3047 make_number (pinfo.pr_start.tv_nsec))),
3048 attrs);
3049 attrs = Fcons (Fcons (Qvsize, make_fixnum_or_float (pinfo.pr_size)), attrs);
3050 attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (pinfo.pr_rssize)), attrs);
3051
3052 /* pr_pctcpu and pr_pctmem are encoded as a fixed point 16 bit number in [0 ... 1]. */
3053 attrs = Fcons (Fcons (Qpcpu, (pinfo.pr_pctcpu * 100.0) / (double)0x8000), attrs);
3054 attrs = Fcons (Fcons (Qpmem, (pinfo.pr_pctmem * 100.0) / (double)0x8000), attrs);
3055
3056 decoded_cmd
3057 = code_convert_string_norecord (make_unibyte_string (pinfo.pr_fname,
3058 strlen (pinfo.pr_fname)),
3059 Vlocale_coding_system, 0);
3060 attrs = Fcons (Fcons (Qcomm, decoded_cmd), attrs);
3061 decoded_cmd
3062 = code_convert_string_norecord (make_unibyte_string (pinfo.pr_psargs,
3063 strlen (pinfo.pr_psargs)),
3064 Vlocale_coding_system, 0);
3065 attrs = Fcons (Fcons (Qargs, decoded_cmd), attrs);
3066 }
3067
2d2d05d8
DN		 3068 if (fd >= 0)
3069 emacs_close (fd);
3070
f4f634e8
DN		 3071 UNGCPRO;
3072 return attrs;
3073}
06e111a6 3074
f8d23104
DN		 3075/* The WINDOWSNT implementation is in w32.c.
3076 The MSDOS implementation is in dosfns.c. */
c4605e09 3077#elif !defined (WINDOWSNT) && !defined (MSDOS)
06e111a6
DN		 3078
3079Lisp_Object
3080system_process_attributes (Lisp_Object pid)
3081{
9dcbe89b 3082 return Qnil;
06e111a6
DN		 3083}
3084
3085#endif /* !defined (WINDOWSNT) */
Unnamed repository; edit this file 'description' to name the repository.