src/sysdep.c

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