src/sysdep.c

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