src/sysdep.c

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