src/sysdep.c

   1 /* Interfaces to system-dependent kernel and library entries.
   2    Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995, 1999, 2000, 2001,
   3                  2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   4                  Free Software Foundation, Inc.
   5
   6 This file is part of GNU Emacs.
   7
   8 GNU Emacs is free software: you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation, either version 3 of the License, or
  11 (at your option) any later version.
  12
  13 GNU Emacs is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include <config.h>
  22 #include <ctype.h>
  23 #include <signal.h>
  24 #include <stdio.h>
  25 #include <setjmp.h>
  26 #ifdef HAVE_PWD_H
  27 #include <pwd.h>
  28 #include <grp.h>
  29 #endif /* HAVE_PWD_H */
  30 #ifdef HAVE_LIMITS_H
  31 #include <limits.h>
  32 #endif /* HAVE_LIMITS_H */
  33 #ifdef HAVE_UNISTD_H
  34 #include <unistd.h>
  35 #endif
  36
  37 #include "lisp.h"
  38 #include "sysselect.h"
  39 #include "blockinput.h"
  40
  41 #ifdef WINDOWSNT
  42 #define read sys_read
  43 #define write sys_write
  44 #include <windows.h>
  45 #ifndef NULL
  46 #define NULL 0
  47 #endif
  48 #endif /* not WINDOWSNT */
  49
  50 #include <sys/types.h>
  51 #include <sys/stat.h>
  52 #include <errno.h>
  53
  54 #ifdef HAVE_SETPGID
  55 #if !defined (USG)
  56 #undef setpgrp
  57 #define setpgrp setpgid
  58 #endif
  59 #endif
  60
  61 /* Get SI_SRPC_DOMAIN, if it is available.  */
  62 #ifdef HAVE_SYS_SYSTEMINFO_H
  63 #include <sys/systeminfo.h>
  64 #endif
  65
  66 #ifdef MSDOS    /* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
  67 #include <dos.h>
  68 #include "dosfns.h"
  69 #include "msdos.h"
  70 #include <sys/param.h>
  71 #endif
  72
  73 #include <sys/file.h>
  74 #include <fcntl.h>
  75
  76 #include "systty.h"
  77 #include "syswait.h"
  78
  79 #ifdef HAVE_SYS_UTSNAME_H
  80 #include <sys/utsname.h>
  81 #include <memory.h>
  82 #endif /* HAVE_SYS_UTSNAME_H */
  83
  84 #include "keyboard.h"
  85 #include "frame.h"
  86 #include "window.h"
  87 #include "termhooks.h"
  88 #include "termchar.h"
  89 #include "termopts.h"
  90 #include "dispextern.h"
  91 #include "process.h"
  92 #include "cm.h"  /* for reset_sys_modes */
  93 #ifdef HAVE_TERM_H
  94 /* Include this last.  If it is ncurses header file, it adds a lot of
  95    defines that interfere with stuff in other headers.  Someone responsible
  96    for ncurses messed up bigtime.  See bug#6812.  */
  97 #include <term.h>
  98 #endif
  99
 100 #ifdef WINDOWSNT
 101 #include <direct.h>
 102 /* In process.h which conflicts with the local copy.  */
 103 #define _P_WAIT 0
 104 int _cdecl _spawnlp (int, const char *, const char *, ...);
 105 int _cdecl _getpid (void);
 106 extern char *getwd (char *);
 107 #endif
 108
 109 #include "syssignal.h"
 110 #include "systime.h"
 111 #ifdef HAVE_UTIME_H
 112 #include <utime.h>
 113 #endif
 114
 115 #ifndef HAVE_UTIMES
 116 #ifndef HAVE_STRUCT_UTIMBUF
 117 /* We want to use utime rather than utimes, but we couldn't find the
 118    structure declaration.  We'll use the traditional one.  */
 119 struct utimbuf {
 120   long actime;
 121   long modtime;
 122 };
 123 #endif
 124 #endif
 125
 126 /* LPASS8 is new in 4.3, and makes cbreak mode provide all 8 bits.  */
 127 #ifndef LPASS8
 128 #define LPASS8 0
 129 #endif
 130
 131 static const int baud_convert[] =
 132   {
 133     0, 50, 75, 110, 135, 150, 200, 300, 600, 1200,
 134     1800, 2400, 4800, 9600, 19200, 38400
 135   };
 136
 137 int emacs_ospeed;
 138
 139 void croak (char *) NO_RETURN;
 140
 141 /* Temporary used by `sigblock' when defined in terms of signprocmask.  */
 142
 143 SIGMASKTYPE sigprocmask_set;
 144
 145
 146 #if !defined (HAVE_GET_CURRENT_DIR_NAME) || defined (BROKEN_GET_CURRENT_DIR_NAME)
 147
 148 /* Return the current working directory.  Returns NULL on errors.
 149    Any other returned value must be freed with free. This is used
 150    only when get_current_dir_name is not defined on the system.  */
 151 char*
 152 get_current_dir_name (void)
 153 {
 154   char *buf;
 155   char *pwd;
 156   struct stat dotstat, pwdstat;
 157   /* If PWD is accurate, use it instead of calling getwd.  PWD is
 158      sometimes a nicer name, and using it may avoid a fatal error if a
 159      parent directory is searchable but not readable.  */
 160     if ((pwd = getenv ("PWD")) != 0
 161       && (IS_DIRECTORY_SEP (*pwd) || (*pwd && IS_DEVICE_SEP (pwd[1])))
 162       && stat (pwd, &pwdstat) == 0
 163       && stat (".", &dotstat) == 0
 164       && dotstat.st_ino == pwdstat.st_ino
 165       && dotstat.st_dev == pwdstat.st_dev
 166 #ifdef MAXPATHLEN
 167       && strlen (pwd) < MAXPATHLEN
 168 #endif
 169       )
 170     {
 171       buf = (char *) malloc (strlen (pwd) + 1);
 172       if (!buf)
 173         return NULL;
 174       strcpy (buf, pwd);
 175     }
 176 #ifdef HAVE_GETCWD
 177   else
 178     {
 179       size_t buf_size = 1024;
 180       buf = (char *) malloc (buf_size);
 181       if (!buf)
 182         return NULL;
 183       for (;;)
 184         {
 185           if (getcwd (buf, buf_size) == buf)
 186             break;
 187           if (errno != ERANGE)
 188             {
 189               int tmp_errno = errno;
 190               free (buf);
 191               errno = tmp_errno;
 192               return NULL;
 193             }
 194           buf_size *= 2;
 195           buf = (char *) realloc (buf, buf_size);
 196           if (!buf)
 197             return NULL;
 198         }
 199     }
 200 #else
 201   else
 202     {
 203       /* We need MAXPATHLEN here.  */
 204       buf = (char *) malloc (MAXPATHLEN + 1);
 205       if (!buf)
 206         return NULL;
 207       if (getwd (buf) == NULL)
 208         {
 209           int tmp_errno = errno;
 210           free (buf);
 211           errno = tmp_errno;
 212           return NULL;
 213         }
 214     }
 215 #endif
 216   return buf;
 217 }
 218 #endif
 219
 220 \f
 221 /* Discard pending input on all input descriptors.  */
 222
 223 void
 224 discard_tty_input (void)
 225 {
 226 #ifndef WINDOWSNT
 227   struct emacs_tty buf;
 228
 229   if (noninteractive)
 230     return;
 231
 232 #ifdef MSDOS    /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
 233   while (dos_keyread () != -1)
 234     ;
 235 #else /* not MSDOS */
 236   {
 237     struct tty_display_info *tty;
 238     for (tty = tty_list; tty; tty = tty->next)
 239       {
 240         if (tty->input)         /* Is the device suspended? */
 241           {
 242             EMACS_GET_TTY (fileno (tty->input), &buf);
 243             EMACS_SET_TTY (fileno (tty->input), &buf, 0);
 244           }
 245       }
 246   }
 247 #endif /* not MSDOS */
 248 #endif /* not WINDOWSNT */
 249 }
 250
 251 \f
 252 #ifdef SIGTSTP
 253
 254 /* Arrange for character C to be read as the next input from
 255    the terminal.
 256    XXX What if we have multiple ttys?
 257 */
 258
 259 void
 260 stuff_char (char c)
 261 {
 262   if (! FRAME_TERMCAP_P (SELECTED_FRAME ()))
 263     return;
 264
 265 /* Should perhaps error if in batch mode */
 266 #ifdef TIOCSTI
 267   ioctl (fileno (CURTTY()->input), TIOCSTI, &c);
 268 #else /* no TIOCSTI */
 269   error ("Cannot stuff terminal input characters in this version of Unix");
 270 #endif /* no TIOCSTI */
 271 }
 272
 273 #endif /* SIGTSTP */
 274 \f
 275 void
 276 init_baud_rate (int fd)
 277 {
 278   if (noninteractive)
 279     emacs_ospeed = 0;
 280   else
 281     {
 282 #ifdef DOS_NT
 283     emacs_ospeed = 15;
 284 #else  /* not DOS_NT */
 285       struct termios sg;
 286
 287       sg.c_cflag = B9600;
 288       tcgetattr (fd, &sg);
 289       emacs_ospeed = cfgetospeed (&sg);
 290 #endif /* not DOS_NT */
 291     }
 292
 293   baud_rate = (emacs_ospeed < sizeof baud_convert / sizeof baud_convert[0]
 294                ? baud_convert[emacs_ospeed] : 9600);
 295   if (baud_rate == 0)
 296     baud_rate = 1200;
 297 }
 298
 299 \f
 300
 301 int wait_debugging;   /* Set nonzero to make following function work under dbx
 302                          (at least for bsd).  */
 303
 304 SIGTYPE
 305 wait_for_termination_signal (void)
 306 {}
 307
 308 #ifndef MSDOS
 309 /* Wait for subprocess with process id `pid' to terminate and
 310    make sure it will get eliminated (not remain forever as a zombie) */
 311
 312 void
 313 wait_for_termination (int pid)
 314 {
 315   while (1)
 316     {
 317 #if defined (BSD_SYSTEM) || defined (HPUX)
 318       /* Note that kill returns -1 even if the process is just a zombie now.
 319          But inevitably a SIGCHLD interrupt should be generated
 320          and child_sig will do wait3 and make the process go away. */
 321       /* There is some indication that there is a bug involved with
 322          termination of subprocesses, perhaps involving a kernel bug too,
 323          but no idea what it is.  Just as a hunch we signal SIGCHLD to see
 324          if that causes the problem to go away or get worse.  */
 325       sigsetmask (sigmask (SIGCHLD));
 326       if (0 > kill (pid, 0))
 327         {
 328           sigsetmask (SIGEMPTYMASK);
 329           kill (getpid (), SIGCHLD);
 330           break;
 331         }
 332       if (wait_debugging)
 333         sleep (1);
 334       else
 335         sigpause (SIGEMPTYMASK);
 336 #else /* not BSD_SYSTEM, and not HPUX version >= 6 */
 337 #ifdef WINDOWSNT
 338       wait (0);
 339       break;
 340 #else /* not WINDOWSNT */
 341       sigblock (sigmask (SIGCHLD));
 342       errno = 0;
 343       if (kill (pid, 0) == -1 && errno == ESRCH)
 344         {
 345           sigunblock (sigmask (SIGCHLD));
 346           break;
 347         }
 348
 349       sigsuspend (&empty_mask);
 350 #endif /* not WINDOWSNT */
 351 #endif /* not BSD_SYSTEM, and not HPUX version >= 6 */
 352     }
 353 }
 354
 355 /*
 356  *      flush any pending output
 357  *      (may flush input as well; it does not matter the way we use it)
 358  */
 359
 360 void
 361 flush_pending_output (int channel)
 362 {
 363   /* FIXME: maybe this function should be removed */
 364 }
 365 \f
 366 /*  Set up the terminal at the other end of a pseudo-terminal that
 367     we will be controlling an inferior through.
 368     It should not echo or do line-editing, since that is done
 369     in Emacs.  No padding needed for insertion into an Emacs buffer.  */
 370
 371 void
 372 child_setup_tty (int out)
 373 {
 374 #ifndef WINDOWSNT
 375   struct emacs_tty s;
 376
 377   EMACS_GET_TTY (out, &s);
 378   s.main.c_oflag |= OPOST;      /* Enable output postprocessing */
 379   s.main.c_oflag &= ~ONLCR;     /* Disable map of NL to CR-NL on output */
 380 #ifdef NLDLY
 381   /* http://lists.gnu.org/archive/html/emacs-devel/2008-05/msg00406.html
 382      Some versions of GNU Hurd do not have FFDLY?  */
 383 #ifdef FFDLY
 384   s.main.c_oflag &= ~(NLDLY|CRDLY|TABDLY|BSDLY|VTDLY|FFDLY);
 385                                 /* No output delays */
 386 #else
 387   s.main.c_oflag &= ~(NLDLY|CRDLY|TABDLY|BSDLY|VTDLY);
 388                                 /* No output delays */
 389 #endif
 390 #endif
 391   s.main.c_lflag &= ~ECHO;      /* Disable echo */
 392   s.main.c_lflag |= ISIG;       /* Enable signals */
 393 #ifdef IUCLC
 394   s.main.c_iflag &= ~IUCLC;     /* Disable downcasing on input.  */
 395 #endif
 396 #ifdef ISTRIP
 397   s.main.c_iflag &= ~ISTRIP;    /* don't strip 8th bit on input */
 398 #endif
 399 #ifdef OLCUC
 400   s.main.c_oflag &= ~OLCUC;     /* Disable upcasing on output.  */
 401 #endif
 402   s.main.c_oflag &= ~TAB3;      /* Disable tab expansion */
 403   s.main.c_cflag = (s.main.c_cflag & ~CSIZE) | CS8; /* Don't strip 8th bit */
 404   s.main.c_cc[VERASE] = CDISABLE;       /* disable erase processing */
 405   s.main.c_cc[VKILL] = CDISABLE;        /* disable kill processing */
 406
 407 #ifdef HPUX
 408   s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
 409 #endif /* HPUX */
 410
 411 #ifdef SIGNALS_VIA_CHARACTERS
 412   /* the QUIT and INTR character are used in process_send_signal
 413      so set them here to something useful.  */
 414   if (s.main.c_cc[VQUIT] == CDISABLE)
 415     s.main.c_cc[VQUIT] = '\\'&037;      /* Control-\ */
 416   if (s.main.c_cc[VINTR] == CDISABLE)
 417     s.main.c_cc[VINTR] = 'C'&037;       /* Control-C */
 418 #endif /* not SIGNALS_VIA_CHARACTERS */
 419
 420 #ifdef AIX
 421   /* Also, PTY overloads NUL and BREAK.
 422      don't ignore break, but don't signal either, so it looks like NUL.  */
 423   s.main.c_iflag &= ~IGNBRK;
 424   s.main.c_iflag &= ~BRKINT;
 425   /* rms: Formerly it set s.main.c_cc[VINTR] to 0377 here
 426      unconditionally.  Then a SIGNALS_VIA_CHARACTERS conditional
 427      would force it to 0377.  That looks like duplicated code.  */
 428   s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
 429 #endif /* AIX */
 430
 431   /* We originally enabled ICANON (and set VEOF to 04), and then had
 432      proces.c send additional EOF chars to flush the output when faced
 433      with long lines, but this leads to weird effects when the
 434      subprocess has disabled ICANON and ends up seeing those spurious
 435      extra EOFs.  So we don't send EOFs any more in
 436      process.c:send_process.  First we tried to disable ICANON by
 437      default, so if a subsprocess sets up ICANON, it's his problem (or
 438      the Elisp package that talks to it) to deal with lines that are
 439      too long.  But this disables some features, such as the ability
 440      to send EOF signals.  So we re-enabled ICANON but there is no
 441      more "send eof to flush" going on (which is wrong and unportable
 442      in itself).  The correct way to handle too much output is to
 443      buffer what could not be written and then write it again when
 444      select returns ok for writing.  This has it own set of
 445      problems.  Write is now asynchronous, is that a problem?  How much
 446      do we buffer, and what do we do when that limit is reached?  */
 447
 448   s.main.c_lflag |= ICANON;     /* Enable line editing and eof processing */
 449   s.main.c_cc[VEOF] = 'D'&037;  /* Control-D */
 450 #if 0       /* These settings only apply to non-ICANON mode. */
 451   s.main.c_cc[VMIN] = 1;
 452   s.main.c_cc[VTIME] = 0;
 453 #endif
 454
 455   EMACS_SET_TTY (out, &s, 0);
 456 #endif /* not WINDOWSNT */
 457 }
 458 #endif  /* not MSDOS */
 459
 460 \f
 461 /* Record a signal code and the handler for it.  */
 462 struct save_signal
 463 {
 464   int code;
 465   SIGTYPE (*handler) (int);
 466 };
 467
 468 static void save_signal_handlers (struct save_signal *);
 469 static void restore_signal_handlers (struct save_signal *);
 470
 471 /* Suspend the Emacs process; give terminal to its superior.  */
 472
 473 void
 474 sys_suspend (void)
 475 {
 476 #if defined (SIGTSTP) && !defined (MSDOS)
 477
 478   {
 479     int pgrp = EMACS_GETPGRP (0);
 480     EMACS_KILLPG (pgrp, SIGTSTP);
 481   }
 482
 483 #else /* No SIGTSTP */
 484 /* On a system where suspending is not implemented,
 485    instead fork a subshell and let it talk directly to the terminal
 486    while we wait.  */
 487   sys_subshell ();
 488
 489 #endif /* no SIGTSTP */
 490 }
 491
 492 /* Fork a subshell.  */
 493
 494 void
 495 sys_subshell (void)
 496 {
 497 #ifdef DOS_NT   /* Demacs 1.1.2 91/10/20 Manabu Higashida */
 498   int st;
 499   char oldwd[MAXPATHLEN+1]; /* Fixed length is safe on MSDOS.  */
 500 #endif
 501   int pid;
 502   struct save_signal saved_handlers[5];
 503   Lisp_Object dir;
 504   unsigned char *str = 0;
 505   int len;
 506
 507   saved_handlers[0].code = SIGINT;
 508   saved_handlers[1].code = SIGQUIT;
 509   saved_handlers[2].code = SIGTERM;
 510 #ifdef SIGIO
 511   saved_handlers[3].code = SIGIO;
 512   saved_handlers[4].code = 0;
 513 #else
 514   saved_handlers[3].code = 0;
 515 #endif
 516
 517   /* Mentioning current_buffer->buffer would mean including buffer.h,
 518      which somehow wedges the hp compiler.  So instead...  */
 519
 520   dir = intern ("default-directory");
 521   if (NILP (Fboundp (dir)))
 522     goto xyzzy;
 523   dir = Fsymbol_value (dir);
 524   if (!STRINGP (dir))
 525     goto xyzzy;
 526
 527   dir = expand_and_dir_to_file (Funhandled_file_name_directory (dir), Qnil);
 528   str = (unsigned char *) alloca (SCHARS (dir) + 2);
 529   len = SCHARS (dir);
 530   memcpy (str, SDATA (dir), len);
 531   if (str[len - 1] != '/') str[len++] = '/';
 532   str[len] = 0;
 533  xyzzy:
 534
 535 #ifdef DOS_NT
 536   pid = 0;
 537   save_signal_handlers (saved_handlers);
 538   synch_process_alive = 1;
 539 #else
 540   pid = vfork ();
 541   if (pid == -1)
 542     error ("Can't spawn subshell");
 543 #endif
 544
 545   if (pid == 0)
 546     {
 547       const char *sh = 0;
 548
 549 #ifdef DOS_NT    /* MW, Aug 1993 */
 550       getwd (oldwd);
 551       if (sh == 0)
 552         sh = (char *) egetenv ("SUSPEND");      /* KFS, 1994-12-14 */
 553 #endif
 554       if (sh == 0)
 555         sh = (char *) egetenv ("SHELL");
 556       if (sh == 0)
 557         sh = "sh";
 558
 559       /* Use our buffer's default directory for the subshell.  */
 560       if (str)
 561         chdir ((char *) str);
 562
 563       close_process_descs ();   /* Close Emacs's pipes/ptys */
 564
 565 #ifdef SET_EMACS_PRIORITY
 566       {
 567         extern EMACS_INT emacs_priority;
 568
 569         if (emacs_priority < 0)
 570           nice (-emacs_priority);
 571       }
 572 #endif
 573
 574 #ifdef MSDOS    /* Demacs 1.1.2 91/10/20 Manabu Higashida */
 575       {
 576         char *epwd = getenv ("PWD");
 577         char old_pwd[MAXPATHLEN+1+4];
 578
 579         /* If PWD is set, pass it with corrected value.  */
 580         if (epwd)
 581           {
 582             strcpy (old_pwd, epwd);
 583             if (str[len - 1] == '/')
 584               str[len - 1] = '\0';
 585             setenv ("PWD", str, 1);
 586           }
 587         st = system (sh);
 588         chdir (oldwd);
 589         if (epwd)
 590           putenv (old_pwd);     /* restore previous value */
 591       }
 592 #else /* not MSDOS */
 593 #ifdef  WINDOWSNT
 594       /* Waits for process completion */
 595       pid = _spawnlp (_P_WAIT, sh, sh, NULL);
 596       chdir (oldwd);
 597       if (pid == -1)
 598         write (1, "Can't execute subshell", 22);
 599 #else   /* not WINDOWSNT */
 600       execlp (sh, sh, (char *) 0);
 601       write (1, "Can't execute subshell", 22);
 602       _exit (1);
 603 #endif  /* not WINDOWSNT */
 604 #endif /* not MSDOS */
 605     }
 606
 607   /* Do this now if we did not do it before.  */
 608 #ifndef MSDOS
 609   save_signal_handlers (saved_handlers);
 610   synch_process_alive = 1;
 611 #endif
 612
 613 #ifndef DOS_NT
 614   wait_for_termination (pid);
 615 #endif
 616   restore_signal_handlers (saved_handlers);
 617   synch_process_alive = 0;
 618 }
 619
 620 static void
 621 save_signal_handlers (struct save_signal *saved_handlers)
 622 {
 623   while (saved_handlers->code)
 624     {
 625       saved_handlers->handler
 626         = (SIGTYPE (*) (int)) signal (saved_handlers->code, SIG_IGN);
 627       saved_handlers++;
 628     }
 629 }
 630
 631 static void
 632 restore_signal_handlers (struct save_signal *saved_handlers)
 633 {
 634   while (saved_handlers->code)
 635     {
 636       signal (saved_handlers->code, saved_handlers->handler);
 637       saved_handlers++;
 638     }
 639 }
 640 \f
 641 #ifndef SIGIO
 642 /* If SIGIO is broken, don't do anything. */
 643 void
 644 init_sigio (int fd)
 645 {
 646 }
 647
 648 void
 649 reset_sigio (int fd)
 650 {
 651 }
 652
 653 void
 654 request_sigio (void)
 655 {
 656 }
 657
 658 void
 659 unrequest_sigio (void)
 660 {
 661 }
 662
 663 #else
 664 #ifdef F_SETFL
 665
 666 int old_fcntl_flags[MAXDESC];
 667
 668 void
 669 init_sigio (int fd)
 670 {
 671 #ifdef FASYNC
 672   old_fcntl_flags[fd] = fcntl (fd, F_GETFL, 0) & ~FASYNC;
 673   fcntl (fd, F_SETFL, old_fcntl_flags[fd] | FASYNC);
 674 #endif
 675   interrupts_deferred = 0;
 676 }
 677
 678 void
 679 reset_sigio (int fd)
 680 {
 681 #ifdef FASYNC
 682   fcntl (fd, F_SETFL, old_fcntl_flags[fd]);
 683 #endif
 684 }
 685
 686 #ifdef FASYNC           /* F_SETFL does not imply existence of FASYNC */
 687 /* XXX Uhm, FASYNC is not used anymore here. */
 688 /* XXX Yeah, but you need it for SIGIO, don't you? */
 689
 690 void
 691 request_sigio (void)
 692 {
 693   if (noninteractive)
 694     return;
 695
 696 #ifdef SIGWINCH
 697   sigunblock (sigmask (SIGWINCH));
 698 #endif
 699   sigunblock (sigmask (SIGIO));
 700
 701   interrupts_deferred = 0;
 702 }
 703
 704 void
 705 unrequest_sigio (void)
 706 {
 707   if (noninteractive)
 708     return;
 709
 710 #if 0 /* XXX What's wrong with blocking SIGIO under X?  */
 711   if (x_display_list)
 712     return;
 713 #endif
 714
 715 #ifdef SIGWINCH
 716   sigblock (sigmask (SIGWINCH));
 717 #endif
 718   sigblock (sigmask (SIGIO));
 719   interrupts_deferred = 1;
 720 }
 721
 722 #else /* no FASYNC */
 723 #ifndef MSDOS
 724
 725 void
 726 request_sigio (void)
 727 {
 728   if (noninteractive || read_socket_hook)
 729     return;
 730
 731   croak ("request_sigio");
 732 }
 733
 734 void
 735 unrequest_sigio (void)
 736 {
 737   if (noninteractive || read_socket_hook)
 738     return;
 739
 740   croak ("unrequest_sigio");
 741 }
 742
 743 #endif /* MSDOS */
 744 #endif /* FASYNC */
 745 #endif /* F_SETFL */
 746 #endif /* SIGIO */
 747
 748 \f
 749 /* Getting and setting emacs_tty structures.  */
 750
 751 /* Set *TC to the parameters associated with the terminal FD.
 752    Return zero if all's well, or -1 if we ran into an error we
 753    couldn't deal with.  */
 754 int
 755 emacs_get_tty (int fd, struct emacs_tty *settings)
 756 {
 757   /* Retrieve the primary parameters - baud rate, character size, etcetera.  */
 758 #ifndef DOS_NT
 759   /* We have those nifty POSIX tcmumbleattr functions.  */
 760   memset (&settings->main, 0, sizeof (settings->main));
 761   if (tcgetattr (fd, &settings->main) < 0)
 762     return -1;
 763 #endif
 764
 765   /* We have survived the tempest.  */
 766   return 0;
 767 }
 768
 769
 770 /* Set the parameters of the tty on FD according to the contents of
 771    *SETTINGS.  If FLUSHP is non-zero, we discard input.
 772    Return 0 if all went well, and -1 if anything failed.  */
 773
 774 int
 775 emacs_set_tty (int fd, struct emacs_tty *settings, int flushp)
 776 {
 777   /* Set the primary parameters - baud rate, character size, etcetera.  */
 778 #ifndef DOS_NT
 779   int i;
 780   /* We have those nifty POSIX tcmumbleattr functions.
 781      William J. Smith <wjs@wiis.wang.com> writes:
 782      "POSIX 1003.1 defines tcsetattr to return success if it was
 783      able to perform any of the requested actions, even if some
 784      of the requested actions could not be performed.
 785      We must read settings back to ensure tty setup properly.
 786      AIX requires this to keep tty from hanging occasionally."  */
 787   /* This make sure that we don't loop indefinitely in here.  */
 788   for (i = 0 ; i < 10 ; i++)
 789     if (tcsetattr (fd, flushp ? TCSAFLUSH : TCSADRAIN, &settings->main) < 0)
 790       {
 791         if (errno == EINTR)
 792           continue;
 793         else
 794           return -1;
 795       }
 796     else
 797       {
 798         struct termios new;
 799
 800         memset (&new, 0, sizeof (new));
 801         /* Get the current settings, and see if they're what we asked for.  */
 802         tcgetattr (fd, &new);
 803         /* We cannot use memcmp on the whole structure here because under
 804          * aix386 the termios structure has some reserved field that may
 805          * not be filled in.
 806          */
 807         if (   new.c_iflag == settings->main.c_iflag
 808             && new.c_oflag == settings->main.c_oflag
 809             && new.c_cflag == settings->main.c_cflag
 810             && new.c_lflag == settings->main.c_lflag
 811             && memcmp (new.c_cc, settings->main.c_cc, NCCS) == 0)
 812           break;
 813         else
 814           continue;
 815       }
 816 #endif
 817
 818   /* We have survived the tempest.  */
 819   return 0;
 820 }
 821
 822 \f
 823
 824 #ifdef F_SETOWN
 825 int old_fcntl_owner[MAXDESC];
 826 #endif /* F_SETOWN */
 827
 828 /* This may also be defined in stdio,
 829    but if so, this does no harm,
 830    and using the same name avoids wasting the other one's space.  */
 831
 832 #if defined (USG)
 833 unsigned char _sobuf[BUFSIZ+8];
 834 #else
 835 char _sobuf[BUFSIZ];
 836 #endif
 837
 838 /* Initialize the terminal mode on all tty devices that are currently
 839    open. */
 840
 841 void
 842 init_all_sys_modes (void)
 843 {
 844   struct tty_display_info *tty;
 845   for (tty = tty_list; tty; tty = tty->next)
 846     init_sys_modes (tty);
 847 }
 848
 849 /* Initialize the terminal mode on the given tty device. */
 850
 851 void
 852 init_sys_modes (struct tty_display_info *tty_out)
 853 {
 854   struct emacs_tty tty;
 855
 856   Vtty_erase_char = Qnil;
 857
 858   if (noninteractive)
 859     return;
 860
 861   if (!tty_out->output)
 862     return;                     /* The tty is suspended. */
 863
 864   if (! tty_out->old_tty)
 865     tty_out->old_tty = (struct emacs_tty *) xmalloc (sizeof (struct emacs_tty));
 866
 867   EMACS_GET_TTY (fileno (tty_out->input), tty_out->old_tty);
 868
 869   tty = *tty_out->old_tty;
 870
 871 #if !defined (DOS_NT)
 872   XSETINT (Vtty_erase_char, tty.main.c_cc[VERASE]);
 873
 874   tty.main.c_iflag |= (IGNBRK); /* Ignore break condition */
 875   tty.main.c_iflag &= ~ICRNL;   /* Disable map of CR to NL on input */
 876 #ifdef INLCR  /* I'm just being cautious,
 877                  since I can't check how widespread INLCR is--rms.  */
 878   tty.main.c_iflag &= ~INLCR;   /* Disable map of NL to CR on input */
 879 #endif
 880 #ifdef ISTRIP
 881   tty.main.c_iflag &= ~ISTRIP;  /* don't strip 8th bit on input */
 882 #endif
 883   tty.main.c_lflag &= ~ECHO;    /* Disable echo */
 884   tty.main.c_lflag &= ~ICANON;  /* Disable erase/kill processing */
 885 #ifdef IEXTEN
 886   tty.main.c_lflag &= ~IEXTEN;  /* Disable other editing characters.  */
 887 #endif
 888   tty.main.c_lflag |= ISIG;     /* Enable signals */
 889   if (tty_out->flow_control)
 890     {
 891       tty.main.c_iflag |= IXON; /* Enable start/stop output control */
 892 #ifdef IXANY
 893       tty.main.c_iflag &= ~IXANY;
 894 #endif /* IXANY */
 895     }
 896   else
 897     tty.main.c_iflag &= ~IXON;  /* Disable start/stop output control */
 898   tty.main.c_oflag &= ~ONLCR;   /* Disable map of NL to CR-NL
 899                                    on output */
 900   tty.main.c_oflag &= ~TAB3;    /* Disable tab expansion */
 901 #ifdef CS8
 902   if (tty_out->meta_key)
 903     {
 904       tty.main.c_cflag |= CS8;  /* allow 8th bit on input */
 905       tty.main.c_cflag &= ~PARENB;/* Don't check parity */
 906     }
 907 #endif
 908   if (tty_out->input == stdin)
 909     {
 910       tty.main.c_cc[VINTR] = quit_char; /* C-g (usually) gives SIGINT */
 911       /* Set up C-g for both SIGQUIT and SIGINT.
 912          We don't know which we will get, but we handle both alike
 913          so which one it really gives us does not matter.  */
 914       tty.main.c_cc[VQUIT] = quit_char;
 915     }
 916   else
 917     {
 918       /* We normally don't get interrupt or quit signals from tty
 919          devices other than our controlling terminal; therefore,
 920          we must handle C-g as normal input.  Unfortunately, this
 921          means that the interrupt and quit feature must be
 922          disabled on secondary ttys, or we would not even see the
 923          keypress.
 924
 925          Note that even though emacsclient could have special code
 926          to pass SIGINT to Emacs, we should _not_ enable
 927          interrupt/quit keys for emacsclient frames.  This means
 928          that we can't break out of loops in C code from a
 929          secondary tty frame, but we can always decide what
 930          display the C-g came from, which is more important from a
 931          usability point of view.  (Consider the case when two
 932          people work together using the same Emacs instance.)  */
 933       tty.main.c_cc[VINTR] = CDISABLE;
 934       tty.main.c_cc[VQUIT] = CDISABLE;
 935     }
 936   tty.main.c_cc[VMIN] = 1;      /* Input should wait for at least 1 char */
 937   tty.main.c_cc[VTIME] = 0;     /* no matter how long that takes.  */
 938 #ifdef VSWTCH
 939   tty.main.c_cc[VSWTCH] = CDISABLE;     /* Turn off shell layering use
 940                                            of C-z */
 941 #endif /* VSWTCH */
 942
 943 #ifdef VSUSP
 944   tty.main.c_cc[VSUSP] = CDISABLE;      /* Turn off handling of C-z.  */
 945 #endif /* VSUSP */
 946 #ifdef V_DSUSP
 947   tty.main.c_cc[V_DSUSP] = CDISABLE; /* Turn off handling of C-y.  */
 948 #endif /* V_DSUSP */
 949 #ifdef VDSUSP /* Some systems have VDSUSP, some have V_DSUSP.  */
 950   tty.main.c_cc[VDSUSP] = CDISABLE;
 951 #endif /* VDSUSP */
 952 #ifdef VLNEXT
 953   tty.main.c_cc[VLNEXT] = CDISABLE;
 954 #endif /* VLNEXT */
 955 #ifdef VREPRINT
 956   tty.main.c_cc[VREPRINT] = CDISABLE;
 957 #endif /* VREPRINT */
 958 #ifdef VWERASE
 959   tty.main.c_cc[VWERASE] = CDISABLE;
 960 #endif /* VWERASE */
 961 #ifdef VDISCARD
 962   tty.main.c_cc[VDISCARD] = CDISABLE;
 963 #endif /* VDISCARD */
 964
 965   if (tty_out->flow_control)
 966     {
 967 #ifdef VSTART
 968       tty.main.c_cc[VSTART] = '\021';
 969 #endif /* VSTART */
 970 #ifdef VSTOP
 971       tty.main.c_cc[VSTOP] = '\023';
 972 #endif /* VSTOP */
 973     }
 974   else
 975     {
 976 #ifdef VSTART
 977       tty.main.c_cc[VSTART] = CDISABLE;
 978 #endif /* VSTART */
 979 #ifdef VSTOP
 980       tty.main.c_cc[VSTOP] = CDISABLE;
 981 #endif /* VSTOP */
 982     }
 983
 984 #ifdef AIX
 985   tty.main.c_cc[VSTRT] = CDISABLE;
 986   tty.main.c_cc[VSTOP] = CDISABLE;
 987   tty.main.c_cc[VSUSP] = CDISABLE;
 988   tty.main.c_cc[VDSUSP] = CDISABLE;
 989   if (tty_out->flow_control)
 990     {
 991 #ifdef VSTART
 992       tty.main.c_cc[VSTART] = '\021';
 993 #endif /* VSTART */
 994 #ifdef VSTOP
 995       tty.main.c_cc[VSTOP] = '\023';
 996 #endif /* VSTOP */
 997     }
 998   /* Also, PTY overloads NUL and BREAK.
 999      don't ignore break, but don't signal either, so it looks like NUL.
1000      This really serves a purpose only if running in an XTERM window
1001      or via TELNET or the like, but does no harm elsewhere.  */
1002   tty.main.c_iflag &= ~IGNBRK;
1003   tty.main.c_iflag &= ~BRKINT;
1004 #endif
1005 #endif /* not DOS_NT */
1006
1007 #ifdef MSDOS    /* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
1008   if (!tty_out->term_initted)
1009     internal_terminal_init ();
1010   dos_ttraw (tty_out);
1011 #endif
1012
1013   EMACS_SET_TTY (fileno (tty_out->input), &tty, 0);
1014
1015   /* This code added to insure that, if flow-control is not to be used,
1016      we have an unlocked terminal at the start. */
1017
1018 #ifdef TCXONC
1019   if (!tty_out->flow_control) ioctl (fileno (tty_out->input), TCXONC, 1);
1020 #endif
1021 #ifdef TIOCSTART
1022   if (!tty_out->flow_control) ioctl (fileno (tty_out->input), TIOCSTART, 0);
1023 #endif
1024
1025 #if !defined (DOS_NT)
1026 #ifdef TCOON
1027   if (!tty_out->flow_control) tcflow (fileno (tty_out->input), TCOON);
1028 #endif
1029 #endif
1030
1031 #ifdef F_SETFL
1032 #ifdef F_GETOWN         /* F_SETFL does not imply existence of F_GETOWN */
1033   if (interrupt_input)
1034     {
1035       old_fcntl_owner[fileno (tty_out->input)] =
1036         fcntl (fileno (tty_out->input), F_GETOWN, 0);
1037       fcntl (fileno (tty_out->input), F_SETOWN, getpid ());
1038       init_sigio (fileno (tty_out->input));
1039 #ifdef HAVE_GPM
1040       if (gpm_tty == tty_out)
1041         {
1042           /* Arrange for mouse events to give us SIGIO signals.  */
1043           fcntl (gpm_fd, F_SETOWN, getpid ());
1044           fcntl (gpm_fd, F_SETFL, fcntl (gpm_fd, F_GETFL, 0) | O_NONBLOCK);
1045           init_sigio (gpm_fd);
1046         }
1047 #endif /* HAVE_GPM */
1048     }
1049 #endif /* F_GETOWN */
1050 #endif /* F_SETFL */
1051
1052 #ifdef _IOFBF
1053   /* This symbol is defined on recent USG systems.
1054      Someone says without this call USG won't really buffer the file
1055      even with a call to setbuf. */
1056   setvbuf (tty_out->output, (char *) _sobuf, _IOFBF, sizeof _sobuf);
1057 #else
1058   setbuf (tty_out->output, (char *) _sobuf);
1059 #endif
1060
1061   if (tty_out->terminal->set_terminal_modes_hook)
1062     tty_out->terminal->set_terminal_modes_hook (tty_out->terminal);
1063
1064   if (!tty_out->term_initted)
1065     {
1066       Lisp_Object tail, frame;
1067       FOR_EACH_FRAME (tail, frame)
1068         {
1069           /* XXX This needs to be revised. */
1070           if (FRAME_TERMCAP_P (XFRAME (frame))
1071               && FRAME_TTY (XFRAME (frame)) == tty_out)
1072             init_frame_faces (XFRAME (frame));
1073         }
1074     }
1075
1076   if (tty_out->term_initted && no_redraw_on_reenter)
1077     {
1078       /* We used to call "direct_output_forward_char(0)" here,
1079          but it's not clear why, since it may not do anything anyway.  */
1080     }
1081   else
1082     {
1083       Lisp_Object tail, frame;
1084       frame_garbaged = 1;
1085       FOR_EACH_FRAME (tail, frame)
1086         {
1087           if ((FRAME_TERMCAP_P (XFRAME (frame))
1088                || FRAME_MSDOS_P (XFRAME (frame)))
1089               && FRAME_TTY (XFRAME (frame)) == tty_out)
1090             FRAME_GARBAGED_P (XFRAME (frame)) = 1;
1091         }
1092     }
1093
1094   tty_out->term_initted = 1;
1095 }
1096
1097 /* Return nonzero if safe to use tabs in output.
1098    At the time this is called, init_sys_modes has not been done yet.  */
1099
1100 int
1101 tabs_safe_p (int fd)
1102 {
1103   struct emacs_tty etty;
1104
1105   EMACS_GET_TTY (fd, &etty);
1106   return EMACS_TTY_TABS_OK (&etty);
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
3079
3080 /* arch-tag: edb43589-4e09-4544-b325-978b5b121dcf
3081    (do not change this comment) */