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 <allocator.h>
  35 #include <careadlinkat.h>
  36 #include <ignore-value.h>
  37
  38 #include "lisp.h"
  39 #include "sysselect.h"
  40 #include "blockinput.h"
  41
  42 #ifdef WINDOWSNT
  43 #define read sys_read
  44 #define write sys_write
  45 #include <windows.h>
  46 #ifndef NULL
  47 #define NULL 0
  48 #endif
  49 #endif /* not WINDOWSNT */
  50
  51 #include <sys/types.h>
  52 #include <sys/stat.h>
  53 #include <errno.h>
  54
  55 #ifdef HAVE_SETPGID
  56 #if !defined (USG)
  57 #undef setpgrp
  58 #define setpgrp setpgid
  59 #endif
  60 #endif
  61
  62 /* Get SI_SRPC_DOMAIN, if it is available.  */
  63 #ifdef HAVE_SYS_SYSTEMINFO_H
  64 #include <sys/systeminfo.h>
  65 #endif
  66
  67 #ifdef MSDOS    /* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
  68 #include <dos.h>
  69 #include "dosfns.h"
  70 #include "msdos.h"
  71 #include <sys/param.h>
  72 #endif
  73
  74 #include <sys/file.h>
  75 #include <fcntl.h>
  76
  77 #include "systty.h"
  78 #include "syswait.h"
  79
  80 #ifdef HAVE_SYS_UTSNAME_H
  81 #include <sys/utsname.h>
  82 #include <memory.h>
  83 #endif /* HAVE_SYS_UTSNAME_H */
  84
  85 #include "keyboard.h"
  86 #include "frame.h"
  87 #include "window.h"
  88 #include "termhooks.h"
  89 #include "termchar.h"
  90 #include "termopts.h"
  91 #include "dispextern.h"
  92 #include "process.h"
  93 #include "cm.h"  /* for reset_sys_modes */
  94
  95 #ifdef WINDOWSNT
  96 #include <direct.h>
  97 /* In process.h which conflicts with the local copy.  */
  98 #define _P_WAIT 0
  99 int _cdecl _spawnlp (int, const char *, const char *, ...);
 100 int _cdecl _getpid (void);
 101 extern char *getwd (char *);
 102 #endif
 103
 104 #include "syssignal.h"
 105 #include "systime.h"
 106 #ifdef HAVE_UTIME_H
 107 #include <utime.h>
 108 #endif
 109
 110 #ifndef HAVE_UTIMES
 111 #ifndef HAVE_STRUCT_UTIMBUF
 112 /* We want to use utime rather than utimes, but we couldn't find the
 113    structure declaration.  We'll use the traditional one.  */
 114 struct utimbuf {
 115   long actime;
 116   long modtime;
 117 };
 118 #endif
 119 #endif
 120
 121 /* Declare here, including term.h is problematic on some systems.  */
 122 extern void tputs (const char *, int, int (*)(int));
 123
 124 static const int baud_convert[] =
 125   {
 126     0, 50, 75, 110, 135, 150, 200, 300, 600, 1200,
 127     1800, 2400, 4800, 9600, 19200, 38400
 128   };
 129
 130 void croak (char *) NO_RETURN;
 131
 132 /* Temporary used by `sigblock' when defined in terms of signprocmask.  */
 133
 134 SIGMASKTYPE sigprocmask_set;
 135
 136
 137 #if !defined (HAVE_GET_CURRENT_DIR_NAME) || defined (BROKEN_GET_CURRENT_DIR_NAME)
 138
 139 /* Return the current working directory.  Returns NULL on errors.
 140    Any other returned value must be freed with free. This is used
 141    only when get_current_dir_name is not defined on the system.  */
 142 char*
 143 get_current_dir_name (void)
 144 {
 145   char *buf;
 146   char *pwd;
 147   struct stat dotstat, pwdstat;
 148   /* If PWD is accurate, use it instead of calling getwd.  PWD is
 149      sometimes a nicer name, and using it may avoid a fatal error if a
 150      parent directory is searchable but not readable.  */
 151     if ((pwd = getenv ("PWD")) != 0
 152       && (IS_DIRECTORY_SEP (*pwd) || (*pwd && IS_DEVICE_SEP (pwd[1])))
 153       && stat (pwd, &pwdstat) == 0
 154       && stat (".", &dotstat) == 0
 155       && dotstat.st_ino == pwdstat.st_ino
 156       && dotstat.st_dev == pwdstat.st_dev
 157 #ifdef MAXPATHLEN
 158       && strlen (pwd) < MAXPATHLEN
 159 #endif
 160       )
 161     {
 162       buf = (char *) malloc (strlen (pwd) + 1);
 163       if (!buf)
 164         return NULL;
 165       strcpy (buf, pwd);
 166     }
 167 #ifdef HAVE_GETCWD
 168   else
 169     {
 170       size_t buf_size = 1024;
 171       buf = (char *) malloc (buf_size);
 172       if (!buf)
 173         return NULL;
 174       for (;;)
 175         {
 176           if (getcwd (buf, buf_size) == buf)
 177             break;
 178           if (errno != ERANGE)
 179             {
 180               int tmp_errno = errno;
 181               free (buf);
 182               errno = tmp_errno;
 183               return NULL;
 184             }
 185           buf_size *= 2;
 186           buf = (char *) realloc (buf, buf_size);
 187           if (!buf)
 188             return NULL;
 189         }
 190     }
 191 #else
 192   else
 193     {
 194       /* We need MAXPATHLEN here.  */
 195       buf = (char *) malloc (MAXPATHLEN + 1);
 196       if (!buf)
 197         return NULL;
 198       if (getwd (buf) == NULL)
 199         {
 200           int tmp_errno = errno;
 201           free (buf);
 202           errno = tmp_errno;
 203           return NULL;
 204         }
 205     }
 206 #endif
 207   return buf;
 208 }
 209 #endif
 210
 211 \f
 212 /* Discard pending input on all input descriptors.  */
 213
 214 void
 215 discard_tty_input (void)
 216 {
 217 #ifndef WINDOWSNT
 218   struct emacs_tty buf;
 219
 220   if (noninteractive)
 221     return;
 222
 223 #ifdef MSDOS    /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
 224   while (dos_keyread () != -1)
 225     ;
 226 #else /* not MSDOS */
 227   {
 228     struct tty_display_info *tty;
 229     for (tty = tty_list; tty; tty = tty->next)
 230       {
 231         if (tty->input)         /* Is the device suspended? */
 232           {
 233             emacs_get_tty (fileno (tty->input), &buf);
 234             emacs_set_tty (fileno (tty->input), &buf, 0);
 235           }
 236       }
 237   }
 238 #endif /* not MSDOS */
 239 #endif /* not WINDOWSNT */
 240 }
 241
 242 \f
 243 #ifdef SIGTSTP
 244
 245 /* Arrange for character C to be read as the next input from
 246    the terminal.
 247    XXX What if we have multiple ttys?
 248 */
 249
 250 void
 251 stuff_char (char c)
 252 {
 253   if (! FRAME_TERMCAP_P (SELECTED_FRAME ()))
 254     return;
 255
 256 /* Should perhaps error if in batch mode */
 257 #ifdef TIOCSTI
 258   ioctl (fileno (CURTTY()->input), TIOCSTI, &c);
 259 #else /* no TIOCSTI */
 260   error ("Cannot stuff terminal input characters in this version of Unix");
 261 #endif /* no TIOCSTI */
 262 }
 263
 264 #endif /* SIGTSTP */
 265 \f
 266 void
 267 init_baud_rate (int fd)
 268 {
 269   int emacs_ospeed;
 270
 271   if (noninteractive)
 272     emacs_ospeed = 0;
 273   else
 274     {
 275 #ifdef DOS_NT
 276     emacs_ospeed = 15;
 277 #else  /* not DOS_NT */
 278       struct termios sg;
 279
 280       sg.c_cflag = B9600;
 281       tcgetattr (fd, &sg);
 282       emacs_ospeed = cfgetospeed (&sg);
 283 #endif /* not DOS_NT */
 284     }
 285
 286   baud_rate = (emacs_ospeed < sizeof baud_convert / sizeof baud_convert[0]
 287                ? baud_convert[emacs_ospeed] : 9600);
 288   if (baud_rate == 0)
 289     baud_rate = 1200;
 290 }
 291
 292 \f
 293
 294 int wait_debugging;   /* Set nonzero to make following function work under dbx
 295                          (at least for bsd).  */
 296
 297 #ifndef MSDOS
 298 /* Wait for subprocess with process id `pid' to terminate and
 299    make sure it will get eliminated (not remain forever as a zombie) */
 300
 301 void
 302 wait_for_termination (int pid)
 303 {
 304   while (1)
 305     {
 306 #if defined (BSD_SYSTEM) || defined (HPUX)
 307       /* Note that kill returns -1 even if the process is just a zombie now.
 308          But inevitably a SIGCHLD interrupt should be generated
 309          and child_sig will do wait3 and make the process go away. */
 310       /* There is some indication that there is a bug involved with
 311          termination of subprocesses, perhaps involving a kernel bug too,
 312          but no idea what it is.  Just as a hunch we signal SIGCHLD to see
 313          if that causes the problem to go away or get worse.  */
 314       sigsetmask (sigmask (SIGCHLD));
 315       if (0 > kill (pid, 0))
 316         {
 317           sigsetmask (SIGEMPTYMASK);
 318           kill (getpid (), SIGCHLD);
 319           break;
 320         }
 321       if (wait_debugging)
 322         sleep (1);
 323       else
 324         sigpause (SIGEMPTYMASK);
 325 #else /* not BSD_SYSTEM, and not HPUX version >= 6 */
 326 #ifdef WINDOWSNT
 327       wait (0);
 328       break;
 329 #else /* not WINDOWSNT */
 330       sigblock (sigmask (SIGCHLD));
 331       errno = 0;
 332       if (kill (pid, 0) == -1 && errno == ESRCH)
 333         {
 334           sigunblock (sigmask (SIGCHLD));
 335           break;
 336         }
 337
 338       sigsuspend (&empty_mask);
 339 #endif /* not WINDOWSNT */
 340 #endif /* not BSD_SYSTEM, and not HPUX version >= 6 */
 341     }
 342 }
 343
 344 /*
 345  *      flush any pending output
 346  *      (may flush input as well; it does not matter the way we use it)
 347  */
 348
 349 void
 350 flush_pending_output (int channel)
 351 {
 352   /* FIXME: maybe this function should be removed */
 353 }
 354 \f
 355 /*  Set up the terminal at the other end of a pseudo-terminal that
 356     we will be controlling an inferior through.
 357     It should not echo or do line-editing, since that is done
 358     in Emacs.  No padding needed for insertion into an Emacs buffer.  */
 359
 360 void
 361 child_setup_tty (int out)
 362 {
 363 #ifndef WINDOWSNT
 364   struct emacs_tty s;
 365
 366   emacs_get_tty (out, &s);
 367   s.main.c_oflag |= OPOST;      /* Enable output postprocessing */
 368   s.main.c_oflag &= ~ONLCR;     /* Disable map of NL to CR-NL on output */
 369 #ifdef NLDLY
 370   /* http://lists.gnu.org/archive/html/emacs-devel/2008-05/msg00406.html
 371      Some versions of GNU Hurd do not have FFDLY?  */
 372 #ifdef FFDLY
 373   s.main.c_oflag &= ~(NLDLY|CRDLY|TABDLY|BSDLY|VTDLY|FFDLY);
 374                                 /* No output delays */
 375 #else
 376   s.main.c_oflag &= ~(NLDLY|CRDLY|TABDLY|BSDLY|VTDLY);
 377                                 /* No output delays */
 378 #endif
 379 #endif
 380   s.main.c_lflag &= ~ECHO;      /* Disable echo */
 381   s.main.c_lflag |= ISIG;       /* Enable signals */
 382 #ifdef IUCLC
 383   s.main.c_iflag &= ~IUCLC;     /* Disable downcasing on input.  */
 384 #endif
 385 #ifdef ISTRIP
 386   s.main.c_iflag &= ~ISTRIP;    /* don't strip 8th bit on input */
 387 #endif
 388 #ifdef OLCUC
 389   s.main.c_oflag &= ~OLCUC;     /* Disable upcasing on output.  */
 390 #endif
 391   s.main.c_oflag &= ~TAB3;      /* Disable tab expansion */
 392   s.main.c_cflag = (s.main.c_cflag & ~CSIZE) | CS8; /* Don't strip 8th bit */
 393   s.main.c_cc[VERASE] = CDISABLE;       /* disable erase processing */
 394   s.main.c_cc[VKILL] = CDISABLE;        /* disable kill processing */
 395
 396 #ifdef HPUX
 397   s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
 398 #endif /* HPUX */
 399
 400 #ifdef SIGNALS_VIA_CHARACTERS
 401   /* the QUIT and INTR character are used in process_send_signal
 402      so set them here to something useful.  */
 403   if (s.main.c_cc[VQUIT] == CDISABLE)
 404     s.main.c_cc[VQUIT] = '\\'&037;      /* Control-\ */
 405   if (s.main.c_cc[VINTR] == CDISABLE)
 406     s.main.c_cc[VINTR] = 'C'&037;       /* Control-C */
 407 #endif /* not SIGNALS_VIA_CHARACTERS */
 408
 409 #ifdef AIX
 410   /* Also, PTY overloads NUL and BREAK.
 411      don't ignore break, but don't signal either, so it looks like NUL.  */
 412   s.main.c_iflag &= ~IGNBRK;
 413   s.main.c_iflag &= ~BRKINT;
 414   /* rms: Formerly it set s.main.c_cc[VINTR] to 0377 here
 415      unconditionally.  Then a SIGNALS_VIA_CHARACTERS conditional
 416      would force it to 0377.  That looks like duplicated code.  */
 417   s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
 418 #endif /* AIX */
 419
 420   /* We originally enabled ICANON (and set VEOF to 04), and then had
 421      proces.c send additional EOF chars to flush the output when faced
 422      with long lines, but this leads to weird effects when the
 423      subprocess has disabled ICANON and ends up seeing those spurious
 424      extra EOFs.  So we don't send EOFs any more in
 425      process.c:send_process.  First we tried to disable ICANON by
 426      default, so if a subsprocess sets up ICANON, it's his problem (or
 427      the Elisp package that talks to it) to deal with lines that are
 428      too long.  But this disables some features, such as the ability
 429      to send EOF signals.  So we re-enabled ICANON but there is no
 430      more "send eof to flush" going on (which is wrong and unportable
 431      in itself).  The correct way to handle too much output is to
 432      buffer what could not be written and then write it again when
 433      select returns ok for writing.  This has it own set of
 434      problems.  Write is now asynchronous, is that a problem?  How much
 435      do we buffer, and what do we do when that limit is reached?  */
 436
 437   s.main.c_lflag |= ICANON;     /* Enable line editing and eof processing */
 438   s.main.c_cc[VEOF] = 'D'&037;  /* Control-D */
 439 #if 0       /* These settings only apply to non-ICANON mode. */
 440   s.main.c_cc[VMIN] = 1;
 441   s.main.c_cc[VTIME] = 0;
 442 #endif
 443
 444   emacs_set_tty (out, &s, 0);
 445 #endif /* not WINDOWSNT */
 446 }
 447 #endif  /* not MSDOS */
 448
 449 \f
 450 /* Record a signal code and the handler for it.  */
 451 struct save_signal
 452 {
 453   int code;
 454   void (*handler) (int);
 455 };
 456
 457 static void save_signal_handlers (struct save_signal *);
 458 static void restore_signal_handlers (struct save_signal *);
 459
 460 /* Suspend the Emacs process; give terminal to its superior.  */
 461
 462 void
 463 sys_suspend (void)
 464 {
 465 #if defined (SIGTSTP) && !defined (MSDOS)
 466
 467   {
 468     int pgrp = EMACS_GETPGRP (0);
 469     EMACS_KILLPG (pgrp, SIGTSTP);
 470   }
 471
 472 #else /* No SIGTSTP */
 473 /* On a system where suspending is not implemented,
 474    instead fork a subshell and let it talk directly to the terminal
 475    while we wait.  */
 476   sys_subshell ();
 477
 478 #endif /* no SIGTSTP */
 479 }
 480
 481 /* Fork a subshell.  */
 482
 483 void
 484 sys_subshell (void)
 485 {
 486 #ifdef DOS_NT   /* Demacs 1.1.2 91/10/20 Manabu Higashida */
 487   int st;
 488   char oldwd[MAXPATHLEN+1]; /* Fixed length is safe on MSDOS.  */
 489 #endif
 490   int pid;
 491   struct save_signal saved_handlers[5];
 492   Lisp_Object dir;
 493   unsigned char *volatile str_volatile = 0;
 494   unsigned char *str;
 495   int len;
 496
 497   saved_handlers[0].code = SIGINT;
 498   saved_handlers[1].code = SIGQUIT;
 499   saved_handlers[2].code = SIGTERM;
 500 #ifdef SIGIO
 501   saved_handlers[3].code = SIGIO;
 502   saved_handlers[4].code = 0;
 503 #else
 504   saved_handlers[3].code = 0;
 505 #endif
 506
 507   /* Mentioning current_buffer->buffer would mean including buffer.h,
 508      which somehow wedges the hp compiler.  So instead...  */
 509
 510   dir = intern ("default-directory");
 511   if (NILP (Fboundp (dir)))
 512     goto xyzzy;
 513   dir = Fsymbol_value (dir);
 514   if (!STRINGP (dir))
 515     goto xyzzy;
 516
 517   dir = expand_and_dir_to_file (Funhandled_file_name_directory (dir), Qnil);
 518   str_volatile = str = (unsigned char *) alloca (SCHARS (dir) + 2);
 519   len = SCHARS (dir);
 520   memcpy (str, SDATA (dir), len);
 521   if (str[len - 1] != '/') str[len++] = '/';
 522   str[len] = 0;
 523  xyzzy:
 524
 525 #ifdef DOS_NT
 526   pid = 0;
 527   save_signal_handlers (saved_handlers);
 528   synch_process_alive = 1;
 529 #else
 530   pid = vfork ();
 531   if (pid == -1)
 532     error ("Can't spawn subshell");
 533 #endif
 534
 535   if (pid == 0)
 536     {
 537       const char *sh = 0;
 538
 539 #ifdef DOS_NT    /* MW, Aug 1993 */
 540       getwd (oldwd);
 541       if (sh == 0)
 542         sh = (char *) egetenv ("SUSPEND");      /* KFS, 1994-12-14 */
 543 #endif
 544       if (sh == 0)
 545         sh = (char *) egetenv ("SHELL");
 546       if (sh == 0)
 547         sh = "sh";
 548
 549       /* Use our buffer's default directory for the subshell.  */
 550       str = str_volatile;
 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         = (void (*) (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 static 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 static 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
1872 static struct allocator const emacs_norealloc_allocator =
1873   { xmalloc, NULL, xfree, memory_full };
1874
1875 /* Get the symbolic link value of FILENAME.  Return a pointer to a
1876    NUL-terminated string.  If readlink fails, return NULL and set
1877    errno.  If the value fits in INITIAL_BUF, return INITIAL_BUF.
1878    Otherwise, allocate memory and return a pointer to that memory.  If
1879    memory allocation fails, diagnose and fail without returning.  If
1880    successful, store the length of the symbolic link into *LINKLEN.  */
1881 char *
1882 emacs_readlink (char const *filename, char initial_buf[READLINK_BUFSIZE])
1883 {
1884   return careadlinkat (AT_FDCWD, filename, initial_buf, READLINK_BUFSIZE,
1885                        &emacs_norealloc_allocator, careadlinkatcwd);
1886 }
1887 \f
1888 #ifdef USG
1889 /*
1890  *      All of the following are for USG.
1891  *
1892  *      On USG systems the system calls are INTERRUPTIBLE by signals
1893  *      that the user program has elected to catch.  Thus the system call
1894  *      must be retried in these cases.  To handle this without massive
1895  *      changes in the source code, we remap the standard system call names
1896  *      to names for our own functions in sysdep.c that do the system call
1897  *      with retries.  Actually, for portability reasons, it is good
1898  *      programming practice, as this example shows, to limit all actual
1899  *      system calls to a single occurrence in the source.  Sure, this
1900  *      adds an extra level of function call overhead but it is almost
1901  *      always negligible.   Fred Fish, Unisoft Systems Inc.
1902  */
1903
1904 /*
1905  *      Warning, this function may not duplicate 4.2 action properly
1906  *      under error conditions.
1907  */
1908
1909 #ifndef HAVE_GETWD
1910
1911 #ifndef MAXPATHLEN
1912 /* In 4.1, param.h fails to define this.  */
1913 #define MAXPATHLEN 1024
1914 #endif
1915
1916 char *
1917 getwd (char *pathname)
1918 {
1919   char *npath, *spath;
1920   extern char *getcwd (char *, size_t);
1921
1922   BLOCK_INPUT;                  /* getcwd uses malloc */
1923   spath = npath = getcwd ((char *) 0, MAXPATHLEN);
1924   if (spath == 0)
1925     {
1926       UNBLOCK_INPUT;
1927       return spath;
1928     }
1929   /* On Altos 3068, getcwd can return @hostname/dir, so discard
1930      up to first slash.  Should be harmless on other systems.  */
1931   while (*npath && *npath != '/')
1932     npath++;
1933   strcpy (pathname, npath);
1934   free (spath);                 /* getcwd uses malloc */
1935   UNBLOCK_INPUT;
1936   return pathname;
1937 }
1938
1939 #endif /* HAVE_GETWD */
1940
1941 /*
1942  *      Emulate rename using unlink/link.  Note that this is
1943  *      only partially correct.  Also, doesn't enforce restriction
1944  *      that files be of same type (regular->regular, dir->dir, etc).
1945  */
1946
1947 #ifndef HAVE_RENAME
1948
1949 int
1950 rename (const char *from, const char *to)
1951 {
1952   if (access (from, 0) == 0)
1953     {
1954       unlink (to);
1955       if (link (from, to) == 0)
1956         if (unlink (from) == 0)
1957           return (0);
1958     }
1959   return (-1);
1960 }
1961
1962 #endif
1963
1964
1965 #if defined(HPUX) && !defined(HAVE_PERROR)
1966
1967 /* HPUX curses library references perror, but as far as we know
1968    it won't be called.  Anyway this definition will do for now.  */
1969
1970 void
1971 perror (void)
1972 {
1973 }
1974 #endif /* HPUX and not HAVE_PERROR */
1975
1976 #ifndef HAVE_DUP2
1977
1978 /*
1979  *      Emulate BSD dup2.  First close newd if it already exists.
1980  *      Then, attempt to dup oldd.  If not successful, call dup2 recursively
1981  *      until we are, then close the unsuccessful ones.
1982  */
1983
1984 int
1985 dup2 (int oldd, int newd)
1986 {
1987   register int fd, ret;
1988
1989   emacs_close (newd);
1990
1991 #ifdef F_DUPFD
1992   return fcntl (oldd, F_DUPFD, newd);
1993 #else
1994   fd = dup (old);
1995   if (fd == -1)
1996     return -1;
1997   if (fd == new)
1998     return new;
1999   ret = dup2 (old,new);
2000   emacs_close (fd);
2001   return ret;
2002 #endif
2003 }
2004
2005 #endif /* not HAVE_DUP2 */
2006
2007 /*
2008  *      Gettimeofday.  Simulate as much as possible.  Only accurate
2009  *      to nearest second.  Emacs doesn't use tzp so ignore it for now.
2010  *      Only needed when subprocesses are defined.
2011  */
2012
2013 #ifndef HAVE_GETTIMEOFDAY
2014 #ifdef HAVE_TIMEVAL
2015
2016 int
2017 gettimeofday (struct timeval *tp, struct timezone *tzp)
2018 {
2019   extern long time (long);
2020
2021   tp->tv_sec = time ((long *)0);
2022   tp->tv_usec = 0;
2023   if (tzp != 0)
2024     tzp->tz_minuteswest = -1;
2025   return 0;
2026 }
2027
2028 #endif
2029 #endif /* !HAVE_GETTIMEOFDAY && HAVE_TIMEVAL */
2030
2031 /*
2032  *      This function will go away as soon as all the stubs fixed. (fnf)
2033  */
2034
2035 void
2036 croak (char *badfunc)
2037 {
2038   printf ("%s not yet implemented\r\n", badfunc);
2039   reset_all_sys_modes ();
2040   exit (1);
2041 }
2042
2043 #endif /* USG */
2044 \f
2045 /* Directory routines for systems that don't have them. */
2046
2047 #ifdef HAVE_DIRENT_H
2048
2049 #include <dirent.h>
2050
2051 #if !defined (HAVE_CLOSEDIR)
2052
2053 int
2054 closedir (DIR *dirp /* stream from opendir */)
2055 {
2056   int rtnval;
2057
2058   rtnval = emacs_close (dirp->dd_fd);
2059   xfree ((char *) dirp);
2060
2061   return rtnval;
2062 }
2063 #endif /* not HAVE_CLOSEDIR */
2064 #endif /* HAVE_DIRENT_H */
2065
2066 \f
2067 int
2068 set_file_times (const char *filename, EMACS_TIME atime, EMACS_TIME mtime)
2069 {
2070 #ifdef HAVE_UTIMES
2071   struct timeval tv[2];
2072   tv[0] = atime;
2073   tv[1] = mtime;
2074   return utimes (filename, tv);
2075 #else /* not HAVE_UTIMES */
2076   struct utimbuf utb;
2077   utb.actime = EMACS_SECS (atime);
2078   utb.modtime = EMACS_SECS (mtime);
2079   return utime (filename, &utb);
2080 #endif /* not HAVE_UTIMES */
2081 }
2082 \f
2083 /* mkdir and rmdir functions, for systems which don't have them.  */
2084
2085 #ifndef HAVE_MKDIR
2086 /*
2087  * Written by Robert Rother, Mariah Corporation, August 1985.
2088  *
2089  * If you want it, it's yours.  All I ask in return is that if you
2090  * figure out how to do this in a Bourne Shell script you send me
2091  * a copy.
2092  *                                      sdcsvax!rmr or rmr@uscd
2093  *
2094  * Severely hacked over by John Gilmore to make a 4.2BSD compatible
2095  * subroutine.  11Mar86; hoptoad!gnu
2096  *
2097  * Modified by rmtodd@uokmax 6-28-87 -- when making an already existing dir,
2098  * subroutine didn't return EEXIST.  It does now.
2099  */
2100
2101 /*
2102  * Make a directory.
2103  */
2104 int
2105 mkdir (char *dpath, int dmode)
2106 {
2107   int cpid, status, fd;
2108   struct stat statbuf;
2109
2110   if (stat (dpath, &statbuf) == 0)
2111     {
2112       errno = EEXIST;           /* Stat worked, so it already exists */
2113       return -1;
2114     }
2115
2116   /* If stat fails for a reason other than non-existence, return error */
2117   if (errno != ENOENT)
2118     return -1;
2119
2120   synch_process_alive = 1;
2121   switch (cpid = fork ())
2122     {
2123
2124     case -1:                    /* Error in fork */
2125       return (-1);              /* Errno is set already */
2126
2127     case 0:                     /* Child process */
2128       /*
2129                  * Cheap hack to set mode of new directory.  Since this
2130                  * child process is going away anyway, we zap its umask.
2131                  * FIXME, this won't suffice to set SUID, SGID, etc. on this
2132                  * directory.  Does anybody care?
2133                  */
2134       status = umask (0);       /* Get current umask */
2135       status = umask (status | (0777 & ~dmode));        /* Set for mkdir */
2136       fd = emacs_open ("/dev/null", O_RDWR, 0);
2137       if (fd >= 0)
2138         {
2139           dup2 (fd, 0);
2140           dup2 (fd, 1);
2141           dup2 (fd, 2);
2142         }
2143       execl ("/bin/mkdir", "mkdir", dpath, (char *) 0);
2144       _exit (-1);               /* Can't exec /bin/mkdir */
2145
2146     default:                    /* Parent process */
2147       wait_for_termination (cpid);
2148     }
2149
2150   if (synch_process_death != 0 || synch_process_retcode != 0
2151       || synch_process_termsig != 0)
2152     {
2153       errno = EIO;              /* We don't know why, but */
2154       return -1;                /* /bin/mkdir failed */
2155     }
2156
2157   return 0;
2158 }
2159 #endif /* not HAVE_MKDIR */
2160
2161 #ifndef HAVE_RMDIR
2162 int
2163 rmdir (char *dpath)
2164 {
2165   int cpid, status, fd;
2166   struct stat statbuf;
2167
2168   if (stat (dpath, &statbuf) != 0)
2169     {
2170       /* Stat just set errno.  We don't have to */
2171       return -1;
2172     }
2173
2174   synch_process_alive = 1;
2175   switch (cpid = fork ())
2176     {
2177
2178     case -1:                    /* Error in fork */
2179       return (-1);              /* Errno is set already */
2180
2181     case 0:                     /* Child process */
2182       fd = emacs_open ("/dev/null", O_RDWR, 0);
2183       if (fd >= 0)
2184         {
2185           dup2 (fd, 0);
2186           dup2 (fd, 1);
2187           dup2 (fd, 2);
2188         }
2189       execl ("/bin/rmdir", "rmdir", dpath, (char *) 0);
2190       _exit (-1);               /* Can't exec /bin/rmdir */
2191
2192     default:                    /* Parent process */
2193       wait_for_termination (cpid);
2194     }
2195
2196   if (synch_process_death != 0 || synch_process_retcode != 0
2197       || synch_process_termsig != 0)
2198     {
2199       errno = EIO;              /* We don't know why, but */
2200       return -1;                /* /bin/rmdir failed */
2201     }
2202
2203   return 0;
2204 }
2205 #endif /* !HAVE_RMDIR */
2206
2207 \f
2208 #ifndef HAVE_MEMSET
2209 void *
2210 memset (void *b, int n, size_t length)
2211 {
2212   unsigned char *p = b;
2213   while (length-- > 0)
2214     *p++ = n;
2215   return b;
2216 }
2217 #endif /* !HAVE_MEMSET */
2218
2219 #ifndef HAVE_MEMCPY
2220 void *
2221 memcpy (void *b1, void *b2, size_t length)
2222 {
2223   unsigned char *p1 = b1, *p2 = b2;
2224   while (length-- > 0)
2225     *p1++ = *p2++;
2226   return b1;
2227 }
2228 #endif /* !HAVE_MEMCPY */
2229
2230 #ifndef HAVE_MEMMOVE
2231 void *
2232 memmove (void *b1, void *b2, size_t length)
2233 {
2234   unsigned char *p1 = b1, *p2 = b2;
2235   if (p1 < p2 || p1 >= p2 + length)
2236     while (length-- > 0)
2237       *p1++ = *p2++;
2238   else
2239     {
2240       p1 += length;
2241       p2 += length;
2242       while (length-- > 0)
2243         *--p1 = *--p2;
2244     }
2245   return b1;
2246 }
2247 #endif /* !HAVE_MEMCPY */
2248
2249 #ifndef HAVE_MEMCMP
2250 int
2251 memcmp (void *b1, void *b2, size_t length)
2252 {
2253   unsigned char *p1 = b1, *p2 = b2;
2254   while (length-- > 0)
2255     if (*p1++ != *p2++)
2256       return p1[-1] < p2[-1] ? -1 : 1;
2257   return 0;
2258 }
2259 #endif /* !HAVE_MEMCMP */
2260 \f
2261 #ifndef HAVE_STRSIGNAL
2262 char *
2263 strsignal (int code)
2264 {
2265   char *signame = 0;
2266
2267   if (0 <= code && code < NSIG)
2268     {
2269       /* Cast to suppress warning if the table has const char *.  */
2270       signame = (char *) sys_siglist[code];
2271     }
2272
2273   return signame;
2274 }
2275 #endif /* HAVE_STRSIGNAL */
2276 \f
2277 #ifndef DOS_NT
2278 /* For make-serial-process  */
2279 int
2280 serial_open (char *port)
2281 {
2282   int fd = -1;
2283
2284   fd = emacs_open ((char*) port,
2285                    O_RDWR
2286 #ifdef O_NONBLOCK
2287                    | O_NONBLOCK
2288 #else
2289                    | O_NDELAY
2290 #endif
2291 #ifdef O_NOCTTY
2292                    | O_NOCTTY
2293 #endif
2294                    , 0);
2295   if (fd < 0)
2296     {
2297       error ("Could not open %s: %s",
2298              port, emacs_strerror (errno));
2299     }
2300 #ifdef TIOCEXCL
2301   ioctl (fd, TIOCEXCL, (char *) 0);
2302 #endif
2303
2304   return fd;
2305 }
2306
2307 #if !defined (HAVE_CFMAKERAW)
2308 /* Workaround for targets which are missing cfmakeraw.  */
2309 /* Pasted from man page.  */
2310 static void
2311 cfmakeraw (struct termios *termios_p)
2312 {
2313     termios_p->c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
2314     termios_p->c_oflag &= ~OPOST;
2315     termios_p->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
2316     termios_p->c_cflag &= ~(CSIZE|PARENB);
2317     termios_p->c_cflag |= CS8;
2318 }
2319 #endif /* !defined (HAVE_CFMAKERAW */
2320
2321 #if !defined (HAVE_CFSETSPEED)
2322 /* Workaround for targets which are missing cfsetspeed.  */
2323 static int
2324 cfsetspeed (struct termios *termios_p, speed_t vitesse)
2325 {
2326   return (cfsetispeed (termios_p, vitesse)
2327           + cfsetospeed (termios_p, vitesse));
2328 }
2329 #endif
2330
2331 /* For serial-process-configure  */
2332 void
2333 serial_configure (struct Lisp_Process *p,
2334                   Lisp_Object contact)
2335 {
2336   Lisp_Object childp2 = Qnil;
2337   Lisp_Object tem = Qnil;
2338   struct termios attr;
2339   int err = -1;
2340   char summary[4] = "???"; /* This usually becomes "8N1".  */
2341
2342   childp2 = Fcopy_sequence (p->childp);
2343
2344   /* Read port attributes and prepare default configuration.  */
2345   err = tcgetattr (p->outfd, &attr);
2346   if (err != 0)
2347     error ("tcgetattr() failed: %s", emacs_strerror (errno));
2348   cfmakeraw (&attr);
2349 #if defined (CLOCAL)
2350   attr.c_cflag |= CLOCAL;
2351 #endif
2352 #if defined (CREAD)
2353   attr.c_cflag |= CREAD;
2354 #endif
2355
2356   /* Configure speed.  */
2357   if (!NILP (Fplist_member (contact, QCspeed)))
2358     tem = Fplist_get (contact, QCspeed);
2359   else
2360     tem = Fplist_get (p->childp, QCspeed);
2361   CHECK_NUMBER (tem);
2362   err = cfsetspeed (&attr, XINT (tem));
2363   if (err != 0)
2364     error ("cfsetspeed(%d) failed: %s", XINT (tem), emacs_strerror (errno));
2365   childp2 = Fplist_put (childp2, QCspeed, tem);
2366
2367   /* Configure bytesize.  */
2368   if (!NILP (Fplist_member (contact, QCbytesize)))
2369     tem = Fplist_get (contact, QCbytesize);
2370   else
2371     tem = Fplist_get (p->childp, QCbytesize);
2372   if (NILP (tem))
2373     tem = make_number (8);
2374   CHECK_NUMBER (tem);
2375   if (XINT (tem) != 7 && XINT (tem) != 8)
2376     error (":bytesize must be nil (8), 7, or 8");
2377   summary[0] = XINT (tem) + '0';
2378 #if defined (CSIZE) && defined (CS7) && defined (CS8)
2379   attr.c_cflag &= ~CSIZE;
2380   attr.c_cflag |= ((XINT (tem) == 7) ? CS7 : CS8);
2381 #else
2382   /* Don't error on bytesize 8, which should be set by cfmakeraw.  */
2383   if (XINT (tem) != 8)
2384     error ("Bytesize cannot be changed");
2385 #endif
2386   childp2 = Fplist_put (childp2, QCbytesize, tem);
2387
2388   /* Configure parity.  */
2389   if (!NILP (Fplist_member (contact, QCparity)))
2390     tem = Fplist_get (contact, QCparity);
2391   else
2392     tem = Fplist_get (p->childp, QCparity);
2393   if (!NILP (tem) && !EQ (tem, Qeven) && !EQ (tem, Qodd))
2394     error (":parity must be nil (no parity), `even', or `odd'");
2395 #if defined (PARENB) && defined (PARODD) && defined (IGNPAR) && defined (INPCK)
2396   attr.c_cflag &= ~(PARENB | PARODD);
2397   attr.c_iflag &= ~(IGNPAR | INPCK);
2398   if (NILP (tem))
2399     {
2400       summary[1] = 'N';
2401     }
2402   else if (EQ (tem, Qeven))
2403     {
2404       summary[1] = 'E';
2405       attr.c_cflag |= PARENB;
2406       attr.c_iflag |= (IGNPAR | INPCK);
2407     }
2408   else if (EQ (tem, Qodd))
2409     {
2410       summary[1] = 'O';
2411       attr.c_cflag |= (PARENB | PARODD);
2412       attr.c_iflag |= (IGNPAR | INPCK);
2413     }
2414 #else
2415   /* Don't error on no parity, which should be set by cfmakeraw.  */
2416   if (!NILP (tem))
2417     error ("Parity cannot be configured");
2418 #endif
2419   childp2 = Fplist_put (childp2, QCparity, tem);
2420
2421   /* Configure stopbits.  */
2422   if (!NILP (Fplist_member (contact, QCstopbits)))
2423     tem = Fplist_get (contact, QCstopbits);
2424   else
2425     tem = Fplist_get (p->childp, QCstopbits);
2426   if (NILP (tem))
2427     tem = make_number (1);
2428   CHECK_NUMBER (tem);
2429   if (XINT (tem) != 1 && XINT (tem) != 2)
2430     error (":stopbits must be nil (1 stopbit), 1, or 2");
2431   summary[2] = XINT (tem) + '0';
2432 #if defined (CSTOPB)
2433   attr.c_cflag &= ~CSTOPB;
2434   if (XINT (tem) == 2)
2435     attr.c_cflag |= CSTOPB;
2436 #else
2437   /* Don't error on 1 stopbit, which should be set by cfmakeraw.  */
2438   if (XINT (tem) != 1)
2439     error ("Stopbits cannot be configured");
2440 #endif
2441   childp2 = Fplist_put (childp2, QCstopbits, tem);
2442
2443   /* Configure flowcontrol.  */
2444   if (!NILP (Fplist_member (contact, QCflowcontrol)))
2445     tem = Fplist_get (contact, QCflowcontrol);
2446   else
2447     tem = Fplist_get (p->childp, QCflowcontrol);
2448   if (!NILP (tem) && !EQ (tem, Qhw) && !EQ (tem, Qsw))
2449     error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
2450 #if defined (CRTSCTS)
2451   attr.c_cflag &= ~CRTSCTS;
2452 #endif
2453 #if defined (CNEW_RTSCTS)
2454   attr.c_cflag &= ~CNEW_RTSCTS;
2455 #endif
2456 #if defined (IXON) && defined (IXOFF)
2457   attr.c_iflag &= ~(IXON | IXOFF);
2458 #endif
2459   if (NILP (tem))
2460     {
2461       /* Already configured.  */
2462     }
2463   else if (EQ (tem, Qhw))
2464     {
2465 #if defined (CRTSCTS)
2466       attr.c_cflag |= CRTSCTS;
2467 #elif defined (CNEW_RTSCTS)
2468       attr.c_cflag |= CNEW_RTSCTS;
2469 #else
2470       error ("Hardware flowcontrol (RTS/CTS) not supported");
2471 #endif
2472     }
2473   else if (EQ (tem, Qsw))
2474     {
2475 #if defined (IXON) && defined (IXOFF)
2476       attr.c_iflag |= (IXON | IXOFF);
2477 #else
2478       error ("Software flowcontrol (XON/XOFF) not supported");
2479 #endif
2480     }
2481   childp2 = Fplist_put (childp2, QCflowcontrol, tem);
2482
2483   /* Activate configuration.  */
2484   err = tcsetattr (p->outfd, TCSANOW, &attr);
2485   if (err != 0)
2486     error ("tcsetattr() failed: %s", emacs_strerror (errno));
2487
2488   childp2 = Fplist_put (childp2, QCsummary, build_string (summary));
2489   p->childp = childp2;
2490
2491 }
2492 #endif /* not DOS_NT  */
2493 \f
2494 /* System depended enumeration of and access to system processes a-la ps(1).  */
2495
2496 #ifdef HAVE_PROCFS
2497
2498 /* Process enumeration and access via /proc.  */
2499
2500 Lisp_Object
2501 list_system_processes (void)
2502 {
2503   Lisp_Object procdir, match, proclist, next;
2504   struct gcpro gcpro1, gcpro2;
2505   register Lisp_Object tail;
2506
2507   GCPRO2 (procdir, match);
2508   /* For every process on the system, there's a directory in the
2509      "/proc" pseudo-directory whose name is the numeric ID of that
2510      process.  */
2511   procdir = build_string ("/proc");
2512   match = build_string ("[0-9]+");
2513   proclist = directory_files_internal (procdir, Qnil, match, Qt, 0, Qnil);
2514
2515   /* `proclist' gives process IDs as strings.  Destructively convert
2516      each string into a number.  */
2517   for (tail = proclist; CONSP (tail); tail = next)
2518     {
2519       next = XCDR (tail);
2520       XSETCAR (tail, Fstring_to_number (XCAR (tail), Qnil));
2521     }
2522   UNGCPRO;
2523
2524   /* directory_files_internal returns the files in reverse order; undo
2525      that.  */
2526   proclist = Fnreverse (proclist);
2527   return proclist;
2528 }
2529
2530 /* The WINDOWSNT implementation is in w32.c.
2531    The MSDOS implementation is in dosfns.c.  */
2532 #elif !defined (WINDOWSNT) && !defined (MSDOS)
2533
2534 Lisp_Object
2535 list_system_processes (void)
2536 {
2537   return Qnil;
2538 }
2539
2540 #endif /* !defined (WINDOWSNT) */
2541
2542 #ifdef GNU_LINUX
2543 static void
2544 time_from_jiffies (unsigned long long tval, long hz,
2545                    time_t *sec, unsigned *usec)
2546 {
2547   unsigned long long ullsec;
2548
2549   *sec = tval / hz;
2550   ullsec = *sec;
2551   tval -= ullsec * hz;
2552   /* Careful: if HZ > 1 million, then integer division by it yields zero.  */
2553   if (hz <= 1000000)
2554     *usec = tval * 1000000 / hz;
2555   else
2556     *usec = tval / (hz / 1000000);
2557 }
2558
2559 static Lisp_Object
2560 ltime_from_jiffies (unsigned long long tval, long hz)
2561 {
2562   time_t sec;
2563   unsigned usec;
2564
2565   time_from_jiffies (tval, hz, &sec, &usec);
2566
2567   return list3 (make_number ((sec >> 16) & 0xffff),
2568                 make_number (sec & 0xffff),
2569                 make_number (usec));
2570 }
2571
2572 static void
2573 get_up_time (time_t *sec, unsigned *usec)
2574 {
2575   FILE *fup;
2576
2577   *sec = *usec = 0;
2578
2579   BLOCK_INPUT;
2580   fup = fopen ("/proc/uptime", "r");
2581
2582   if (fup)
2583     {
2584       double uptime, idletime;
2585
2586       /* The numbers in /proc/uptime use C-locale decimal point, but
2587          we already set ourselves to the C locale (see `fixup_locale'
2588          in emacs.c).  */
2589       if (2 <= fscanf (fup, "%lf %lf", &uptime, &idletime))
2590         {
2591           *sec = uptime;
2592           *usec = (uptime - *sec) * 1000000;
2593         }
2594       fclose (fup);
2595     }
2596   UNBLOCK_INPUT;
2597 }
2598
2599 #define MAJOR(d) (((unsigned)(d) >> 8) & 0xfff)
2600 #define MINOR(d) (((unsigned)(d) & 0xff) | (((unsigned)(d) & 0xfff00000) >> 12))
2601
2602 static Lisp_Object
2603 procfs_ttyname (int rdev)
2604 {
2605   FILE *fdev = NULL;
2606   char name[PATH_MAX];
2607
2608   BLOCK_INPUT;
2609   fdev = fopen ("/proc/tty/drivers", "r");
2610
2611   if (fdev)
2612     {
2613       unsigned major;
2614       unsigned long minor_beg, minor_end;
2615       char minor[25];   /* 2 32-bit numbers + dash */
2616       char *endp;
2617
2618       while (!feof (fdev) && !ferror (fdev))
2619         {
2620           if (3 <= fscanf (fdev, "%*s %s %u %s %*s\n", name, &major, minor)
2621               && major == MAJOR (rdev))
2622             {
2623               minor_beg = strtoul (minor, &endp, 0);
2624               if (*endp == '\0')
2625                 minor_end = minor_beg;
2626               else if (*endp == '-')
2627                 minor_end = strtoul (endp + 1, &endp, 0);
2628               else
2629                 continue;
2630
2631               if (MINOR (rdev) >= minor_beg && MINOR (rdev) <= minor_end)
2632                 {
2633                   sprintf (name + strlen (name), "%u", MINOR (rdev));
2634                   break;
2635                 }
2636             }
2637         }
2638       fclose (fdev);
2639     }
2640   UNBLOCK_INPUT;
2641   return build_string (name);
2642 }
2643
2644 static unsigned long
2645 procfs_get_total_memory (void)
2646 {
2647   FILE *fmem = NULL;
2648   unsigned long retval = 2 * 1024 * 1024; /* default: 2GB */
2649
2650   BLOCK_INPUT;
2651   fmem = fopen ("/proc/meminfo", "r");
2652
2653   if (fmem)
2654     {
2655       unsigned long entry_value;
2656       char entry_name[20];      /* the longest I saw is 13+1 */
2657
2658       while (!feof (fmem) && !ferror (fmem))
2659         {
2660           if (2 <= fscanf (fmem, "%s %lu kB\n", entry_name, &entry_value)
2661               && strcmp (entry_name, "MemTotal:") == 0)
2662             {
2663               retval = entry_value;
2664               break;
2665             }
2666         }
2667       fclose (fmem);
2668     }
2669   UNBLOCK_INPUT;
2670   return retval;
2671 }
2672
2673 Lisp_Object
2674 system_process_attributes (Lisp_Object pid)
2675 {
2676   char procfn[PATH_MAX], fn[PATH_MAX];
2677   struct stat st;
2678   struct passwd *pw;
2679   struct group *gr;
2680   long clocks_per_sec;
2681   char *procfn_end;
2682   char procbuf[1025], *p, *q;
2683   int fd;
2684   ssize_t nread;
2685   const char *cmd = NULL;
2686   char *cmdline = NULL;
2687   size_t cmdsize = 0, cmdline_size;
2688   unsigned char c;
2689   int proc_id, ppid, uid, gid, pgrp, sess, tty, tpgid, thcount;
2690   unsigned long long u_time, s_time, cutime, cstime, start;
2691   long priority, niceness, rss;
2692   unsigned long minflt, majflt, cminflt, cmajflt, vsize;
2693   time_t sec;
2694   unsigned usec;
2695   EMACS_TIME tnow, tstart, tboot, telapsed;
2696   double pcpu, pmem;
2697   Lisp_Object attrs = Qnil;
2698   Lisp_Object cmd_str, decoded_cmd, tem;
2699   struct gcpro gcpro1, gcpro2;
2700   EMACS_INT uid_eint, gid_eint;
2701
2702   CHECK_NUMBER_OR_FLOAT (pid);
2703   proc_id = FLOATP (pid) ? XFLOAT_DATA (pid) : XINT (pid);
2704   sprintf (procfn, "/proc/%u", proc_id);
2705   if (stat (procfn, &st) < 0)
2706     return attrs;
2707
2708   GCPRO2 (attrs, decoded_cmd);
2709
2710   /* euid egid */
2711   uid = st.st_uid;
2712   /* Use of EMACS_INT stops GCC whining about limited range of data type.  */
2713   uid_eint = uid;
2714   attrs = Fcons (Fcons (Qeuid, make_fixnum_or_float (uid_eint)), attrs);
2715   BLOCK_INPUT;
2716   pw = getpwuid (uid);
2717   UNBLOCK_INPUT;
2718   if (pw)
2719     attrs = Fcons (Fcons (Quser, build_string (pw->pw_name)), attrs);
2720
2721   gid = st.st_gid;
2722   gid_eint = gid;
2723   attrs = Fcons (Fcons (Qegid, make_fixnum_or_float (gid_eint)), attrs);
2724   BLOCK_INPUT;
2725   gr = getgrgid (gid);
2726   UNBLOCK_INPUT;
2727   if (gr)
2728     attrs = Fcons (Fcons (Qgroup, build_string (gr->gr_name)), attrs);
2729
2730   strcpy (fn, procfn);
2731   procfn_end = fn + strlen (fn);
2732   strcpy (procfn_end, "/stat");
2733   fd = emacs_open (fn, O_RDONLY, 0);
2734   if (fd >= 0 && (nread = emacs_read (fd, procbuf, sizeof (procbuf) - 1)) > 0)
2735     {
2736       procbuf[nread] = '\0';
2737       p = procbuf;
2738
2739       p = strchr (p, '(');
2740       if (p != NULL)
2741         {
2742           q = strrchr (p + 1, ')');
2743           /* comm */
2744           if (q != NULL)
2745             {
2746               cmd = p + 1;
2747               cmdsize = q - cmd;
2748             }
2749         }
2750       else
2751         q = NULL;
2752       if (cmd == NULL)
2753         {
2754           cmd = "???";
2755           cmdsize = 3;
2756         }
2757       /* Command name is encoded in locale-coding-system; decode it.  */
2758       cmd_str = make_unibyte_string (cmd, cmdsize);
2759       decoded_cmd = code_convert_string_norecord (cmd_str,
2760                                                   Vlocale_coding_system, 0);
2761       attrs = Fcons (Fcons (Qcomm, decoded_cmd), attrs);
2762
2763       if (q)
2764         {
2765           EMACS_INT ppid_eint, pgrp_eint, sess_eint, tpgid_eint, thcount_eint;
2766           p = q + 2;
2767           /* state ppid pgrp sess tty tpgid . minflt cminflt majflt cmajflt utime stime cutime cstime priority nice thcount . start vsize rss */
2768           sscanf (p, "%c %d %d %d %d %d %*u %lu %lu %lu %lu %Lu %Lu %Lu %Lu %ld %ld %d %*d %Lu %lu %ld",
2769                   &c, &ppid, &pgrp, &sess, &tty, &tpgid,
2770                   &minflt, &cminflt, &majflt, &cmajflt,
2771                   &u_time, &s_time, &cutime, &cstime,
2772                   &priority, &niceness, &thcount, &start, &vsize, &rss);
2773           {
2774             char state_str[2];
2775
2776             state_str[0] = c;
2777             state_str[1] = '\0';
2778             tem =  build_string (state_str);
2779             attrs = Fcons (Fcons (Qstate, tem), attrs);
2780           }
2781           /* Stops GCC whining about limited range of data type.  */
2782           ppid_eint = ppid;
2783           pgrp_eint = pgrp;
2784           sess_eint = sess;
2785           tpgid_eint = tpgid;
2786           thcount_eint = thcount;
2787           attrs = Fcons (Fcons (Qppid, make_fixnum_or_float (ppid_eint)), attrs);
2788           attrs = Fcons (Fcons (Qpgrp, make_fixnum_or_float (pgrp_eint)), attrs);
2789           attrs = Fcons (Fcons (Qsess, make_fixnum_or_float (sess_eint)), attrs);
2790           attrs = Fcons (Fcons (Qttname, procfs_ttyname (tty)), attrs);
2791           attrs = Fcons (Fcons (Qtpgid, make_fixnum_or_float (tpgid_eint)), attrs);
2792           attrs = Fcons (Fcons (Qminflt, make_fixnum_or_float (minflt)), attrs);
2793           attrs = Fcons (Fcons (Qmajflt, make_fixnum_or_float (majflt)), attrs);
2794           attrs = Fcons (Fcons (Qcminflt, make_fixnum_or_float (cminflt)), attrs);
2795           attrs = Fcons (Fcons (Qcmajflt, make_fixnum_or_float (cmajflt)), attrs);
2796           clocks_per_sec = sysconf (_SC_CLK_TCK);
2797           if (clocks_per_sec < 0)
2798             clocks_per_sec = 100;
2799           attrs = Fcons (Fcons (Qutime,
2800                                 ltime_from_jiffies (u_time, clocks_per_sec)),
2801                          attrs);
2802           attrs = Fcons (Fcons (Qstime,
2803                                 ltime_from_jiffies (s_time, clocks_per_sec)),
2804                          attrs);
2805           attrs = Fcons (Fcons (Qtime,
2806                                 ltime_from_jiffies (s_time + u_time,
2807                                                     clocks_per_sec)),
2808                          attrs);
2809           attrs = Fcons (Fcons (Qcutime,
2810                                 ltime_from_jiffies (cutime, clocks_per_sec)),
2811                          attrs);
2812           attrs = Fcons (Fcons (Qcstime,
2813                                 ltime_from_jiffies (cstime, clocks_per_sec)),
2814                          attrs);
2815           attrs = Fcons (Fcons (Qctime,
2816                                 ltime_from_jiffies (cstime+cutime, clocks_per_sec)),
2817                          attrs);
2818           attrs = Fcons (Fcons (Qpri, make_number (priority)), attrs);
2819           attrs = Fcons (Fcons (Qnice, make_number (niceness)), attrs);
2820           attrs = Fcons (Fcons (Qthcount, make_fixnum_or_float (thcount_eint)), attrs);
2821           EMACS_GET_TIME (tnow);
2822           get_up_time (&sec, &usec);
2823           EMACS_SET_SECS (telapsed, sec);
2824           EMACS_SET_USECS (telapsed, usec);
2825           EMACS_SUB_TIME (tboot, tnow, telapsed);
2826           time_from_jiffies (start, clocks_per_sec, &sec, &usec);
2827           EMACS_SET_SECS (tstart, sec);
2828           EMACS_SET_USECS (tstart, usec);
2829           EMACS_ADD_TIME (tstart, tboot, tstart);
2830           attrs = Fcons (Fcons (Qstart,
2831                                 list3 (make_number
2832                                        ((EMACS_SECS (tstart) >> 16) & 0xffff),
2833                                        make_number
2834                                        (EMACS_SECS (tstart) & 0xffff),
2835                                        make_number
2836                                        (EMACS_USECS (tstart)))),
2837                          attrs);
2838           attrs = Fcons (Fcons (Qvsize, make_fixnum_or_float (vsize/1024)), attrs);
2839           attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (4*rss)), attrs);
2840           EMACS_SUB_TIME (telapsed, tnow, tstart);
2841           attrs = Fcons (Fcons (Qetime,
2842                                 list3 (make_number
2843                                        ((EMACS_SECS (telapsed) >> 16) & 0xffff),
2844                                        make_number
2845                                        (EMACS_SECS (telapsed) & 0xffff),
2846                                        make_number
2847                                        (EMACS_USECS (telapsed)))),
2848                          attrs);
2849           time_from_jiffies (u_time + s_time, clocks_per_sec, &sec, &usec);
2850           pcpu = (sec + usec / 1000000.0) / (EMACS_SECS (telapsed) + EMACS_USECS (telapsed) / 1000000.0);
2851           if (pcpu > 1.0)
2852             pcpu = 1.0;
2853           attrs = Fcons (Fcons (Qpcpu, make_float (100 * pcpu)), attrs);
2854           pmem = 4.0 * 100 * rss / procfs_get_total_memory ();
2855           if (pmem > 100)
2856             pmem = 100;
2857           attrs = Fcons (Fcons (Qpmem, make_float (pmem)), attrs);
2858         }
2859     }
2860   if (fd >= 0)
2861     emacs_close (fd);
2862
2863   /* args */
2864   strcpy (procfn_end, "/cmdline");
2865   fd = emacs_open (fn, O_RDONLY, 0);
2866   if (fd >= 0)
2867     {
2868       char ch;
2869       for (cmdline_size = 0; emacs_read (fd, &ch, 1) == 1; cmdline_size++)
2870         {
2871           c = ch;
2872           if (isspace (c) || c == '\\')
2873             cmdline_size++;     /* for later quoting, see below */
2874         }
2875       if (cmdline_size)
2876         {
2877           cmdline = xmalloc (cmdline_size + 1);
2878           lseek (fd, 0L, SEEK_SET);
2879           cmdline[0] = '\0';
2880           if ((nread = read (fd, cmdline, cmdline_size)) >= 0)
2881             cmdline[nread++] = '\0';
2882           else
2883             {
2884               /* Assigning zero to `nread' makes us skip the following
2885                  two loops, assign zero to cmdline_size, and enter the
2886                  following `if' clause that handles unknown command
2887                  lines.  */
2888               nread = 0;
2889             }
2890           /* We don't want trailing null characters.  */
2891           for (p = cmdline + nread - 1; p > cmdline && !*p; p--)
2892             nread--;
2893           for (p = cmdline; p < cmdline + nread; p++)
2894             {
2895               /* Escape-quote whitespace and backslashes.  */
2896               if (isspace (*p) || *p == '\\')
2897                 {
2898                   memmove (p + 1, p, nread - (p - cmdline));
2899                   nread++;
2900                   *p++ = '\\';
2901                 }
2902               else if (*p == '\0')
2903                 *p = ' ';
2904             }
2905           cmdline_size = nread;
2906         }
2907       if (!cmdline_size)
2908         {
2909           if (!cmd)
2910             cmd = "???";
2911           if (!cmdsize)
2912             cmdsize = strlen (cmd);
2913           cmdline_size = cmdsize + 2;
2914           cmdline = xmalloc (cmdline_size + 1);
2915           strcpy (cmdline, "[");
2916           strcat (strncat (cmdline, cmd, cmdsize), "]");
2917         }
2918       emacs_close (fd);
2919       /* Command line is encoded in locale-coding-system; decode it.  */
2920       cmd_str = make_unibyte_string (cmdline, cmdline_size);
2921       decoded_cmd = code_convert_string_norecord (cmd_str,
2922                                                   Vlocale_coding_system, 0);
2923       xfree (cmdline);
2924       attrs = Fcons (Fcons (Qargs, decoded_cmd), attrs);
2925     }
2926
2927   UNGCPRO;
2928   return attrs;
2929 }
2930
2931 #elif defined (SOLARIS2) && defined (HAVE_PROCFS)
2932
2933 /* The <procfs.h> header does not like to be included if _LP64 is defined and
2934    __FILE_OFFSET_BITS == 64.  This is an ugly workaround that.  */
2935 #if !defined (_LP64) && defined (_FILE_OFFSET_BITS) &&  (_FILE_OFFSET_BITS  ==  64)
2936 #define PROCFS_FILE_OFFSET_BITS_HACK 1
2937 #undef _FILE_OFFSET_BITS
2938 #else
2939 #define PROCFS_FILE_OFFSET_BITS_HACK 0
2940 #endif
2941
2942 #include <procfs.h>
2943
2944 #if PROCFS_FILE_OFFSET_BITS_HACK ==  1
2945 #define _FILE_OFFSET_BITS 64
2946 #endif /* PROCFS_FILE_OFFSET_BITS_HACK ==  1 */
2947
2948 Lisp_Object
2949 system_process_attributes (Lisp_Object pid)
2950 {
2951   char procfn[PATH_MAX], fn[PATH_MAX];
2952   struct stat st;
2953   struct passwd *pw;
2954   struct group *gr;
2955   char *procfn_end;
2956   struct psinfo pinfo;
2957   int fd;
2958   ssize_t nread;
2959   int proc_id, uid, gid;
2960   Lisp_Object attrs = Qnil;
2961   Lisp_Object decoded_cmd, tem;
2962   struct gcpro gcpro1, gcpro2;
2963   EMACS_INT uid_eint, gid_eint;
2964
2965   CHECK_NUMBER_OR_FLOAT (pid);
2966   proc_id = FLOATP (pid) ? XFLOAT_DATA (pid) : XINT (pid);
2967   sprintf (procfn, "/proc/%u", proc_id);
2968   if (stat (procfn, &st) < 0)
2969     return attrs;
2970
2971   GCPRO2 (attrs, decoded_cmd);
2972
2973   /* euid egid */
2974   uid = st.st_uid;
2975   /* Use of EMACS_INT stops GCC whining about limited range of data type.  */
2976   uid_eint = uid;
2977   attrs = Fcons (Fcons (Qeuid, make_fixnum_or_float (uid_eint)), attrs);
2978   BLOCK_INPUT;
2979   pw = getpwuid (uid);
2980   UNBLOCK_INPUT;
2981   if (pw)
2982     attrs = Fcons (Fcons (Quser, build_string (pw->pw_name)), attrs);
2983
2984   gid = st.st_gid;
2985   gid_eint = gid;
2986   attrs = Fcons (Fcons (Qegid, make_fixnum_or_float (gid_eint)), attrs);
2987   BLOCK_INPUT;
2988   gr = getgrgid (gid);
2989   UNBLOCK_INPUT;
2990   if (gr)
2991     attrs = Fcons (Fcons (Qgroup, build_string (gr->gr_name)), attrs);
2992
2993   strcpy (fn, procfn);
2994   procfn_end = fn + strlen (fn);
2995   strcpy (procfn_end, "/psinfo");
2996   fd = emacs_open (fn, O_RDONLY, 0);
2997   if (fd >= 0
2998       && (nread = read (fd, (char*)&pinfo, sizeof (struct psinfo)) > 0))
2999     {
3000           attrs = Fcons (Fcons (Qppid, make_fixnum_or_float (pinfo.pr_ppid)), attrs);
3001           attrs = Fcons (Fcons (Qpgrp, make_fixnum_or_float (pinfo.pr_pgid)), attrs);
3002           attrs = Fcons (Fcons (Qsess, make_fixnum_or_float (pinfo.pr_sid)), attrs);
3003
3004           {
3005             char state_str[2];
3006             state_str[0] =  pinfo.pr_lwp.pr_sname;
3007             state_str[1] =  '\0';
3008             tem =   build_string (state_str);
3009             attrs =  Fcons (Fcons (Qstate,  tem),  attrs);
3010           }
3011
3012           /* FIXME: missing Qttyname. psinfo.pr_ttydev is a dev_t,
3013              need to get a string from it. */
3014
3015           /* FIXME: missing: Qtpgid */
3016
3017           /* FIXME: missing:
3018                 Qminflt
3019                 Qmajflt
3020                 Qcminflt
3021                 Qcmajflt
3022
3023                 Qutime
3024                 Qcutime
3025                 Qstime
3026                 Qcstime
3027                 Are they available? */
3028
3029           attrs = Fcons (Fcons (Qtime,
3030                                 list3 (make_number (pinfo.pr_time.tv_sec >> 16),
3031                                        make_number (pinfo.pr_time.tv_sec & 0xffff),
3032                                        make_number (pinfo.pr_time.tv_nsec))),
3033                          attrs);
3034
3035           attrs = Fcons (Fcons (Qctime,
3036                                 list3 (make_number (pinfo.pr_ctime.tv_sec >> 16),
3037                                        make_number (pinfo.pr_ctime.tv_sec & 0xffff),
3038                                        make_number (pinfo.pr_ctime.tv_nsec))),
3039                          attrs);
3040
3041           attrs = Fcons (Fcons (Qpri, make_number (pinfo.pr_lwp.pr_pri)), attrs);
3042           attrs = Fcons (Fcons (Qnice, make_number (pinfo.pr_lwp.pr_nice)), attrs);
3043           attrs = Fcons (Fcons (Qthcount, make_fixnum_or_float (pinfo.pr_nlwp)), attrs);
3044
3045           attrs = Fcons (Fcons (Qstart,
3046                                 list3 (make_number (pinfo.pr_start.tv_sec >> 16),
3047                                        make_number (pinfo.pr_start.tv_sec & 0xffff),
3048                                        make_number (pinfo.pr_start.tv_nsec))),
3049                          attrs);
3050           attrs = Fcons (Fcons (Qvsize, make_fixnum_or_float (pinfo.pr_size)), attrs);
3051           attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (pinfo.pr_rssize)), attrs);
3052
3053           /* pr_pctcpu and pr_pctmem are encoded as a fixed point 16 bit number in  [0 ... 1].  */
3054           attrs = Fcons (Fcons (Qpcpu, (pinfo.pr_pctcpu * 100.0) / (double)0x8000), attrs);
3055           attrs = Fcons (Fcons (Qpmem, (pinfo.pr_pctmem * 100.0) / (double)0x8000), attrs);
3056
3057           decoded_cmd
3058             =  code_convert_string_norecord (make_unibyte_string (pinfo.pr_fname,
3059                                                                   strlen (pinfo.pr_fname)),
3060                                              Vlocale_coding_system,  0);
3061           attrs =  Fcons (Fcons (Qcomm,  decoded_cmd),  attrs);
3062           decoded_cmd
3063             =  code_convert_string_norecord (make_unibyte_string (pinfo.pr_psargs,
3064                                                                   strlen (pinfo.pr_psargs)),
3065                                              Vlocale_coding_system,  0);
3066           attrs =  Fcons (Fcons (Qargs,  decoded_cmd),  attrs);
3067     }
3068
3069   if (fd >= 0)
3070     emacs_close (fd);
3071
3072   UNGCPRO;
3073   return attrs;
3074 }
3075
3076 /* The WINDOWSNT implementation is in w32.c.
3077    The MSDOS implementation is in dosfns.c.  */
3078 #elif !defined (WINDOWSNT) && !defined (MSDOS)
3079
3080 Lisp_Object
3081 system_process_attributes (Lisp_Object pid)
3082 {
3083   return Qnil;
3084 }
3085
3086 #endif  /* !defined (WINDOWSNT) */