src/sysdep.c

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