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