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