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