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