src/sysdep.c

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