src/sysdep.c

   1 /* Interfaces to system-dependent kernel and library entries.
   2    Copyright (C) 1985, 86, 87, 88, 93, 94 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Emacs.
   5
   6 GNU Emacs is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Emacs is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Emacs; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20
  21 #include <signal.h>
  22 #include <setjmp.h>
  23
  24 #include <config.h>
  25 #include "lisp.h"
  26 #include "blockinput.h"
  27 #undef NULL
  28
  29 #define min(x,y) ((x) > (y) ? (y) : (x))
  30
  31 /* In this file, open, read and write refer to the system calls,
  32    not our sugared interfaces  sys_open, sys_read and sys_write.
  33    Contrariwise, for systems where we use the system calls directly,
  34    define sys_read, etc. here as aliases for them.  */
  35 #ifndef read
  36 #define sys_read read
  37 #define sys_write write
  38 #endif /* `read' is not a macro */
  39
  40 #undef read
  41 #undef write
  42
  43 #ifndef close
  44 #define sys_close close
  45 #else
  46 #undef close
  47 #endif
  48
  49 #ifndef open
  50 #define sys_open open
  51 #else /* `open' is a macro */
  52 #undef open
  53 #endif /* `open' is a macro */
  54
  55 /* Does anyone other than VMS need this? */
  56 #ifndef fwrite
  57 #define sys_fwrite fwrite
  58 #else
  59 #undef fwrite
  60 #endif
  61
  62 #include <stdio.h>
  63 #include <sys/types.h>
  64 #include <sys/stat.h>
  65 #include <errno.h>
  66
  67 #ifdef MSDOS    /* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
  68 #include <dos.h>
  69 #include "dosfns.h"
  70 #include "msdos.h"
  71 #include <sys/param.h>
  72 #endif
  73
  74 extern int errno;
  75
  76 #ifdef VMS
  77 #include <rms.h>
  78 #include <ttdef.h>
  79 #include <tt2def.h>
  80 #include <iodef.h>
  81 #include <ssdef.h>
  82 #include <descrip.h>
  83 #include <fibdef.h>
  84 #include <atrdef.h>
  85 #include <ctype.h>
  86 #include <string.h>
  87 #ifdef __GNUC__
  88 #include <sys/file.h>
  89 #else
  90 #include <file.h>
  91 #endif
  92 #undef F_SETFL
  93 #ifndef RAB$C_BID
  94 #include <rab.h>
  95 #endif
  96 #define MAXIOSIZE ( 32 * PAGESIZE )     /* Don't I/O more than 32 blocks at a time */
  97 #endif /* VMS */
  98
  99 #ifndef BSD4_1
 100 #ifdef BSD /* this is done this way to avoid defined (BSD) || defined (USG)
 101               because the vms compiler doesn't grok `defined' */
 102 #include <fcntl.h>
 103 #endif
 104 #ifdef USG
 105 #ifndef USG5
 106 #include <fcntl.h>
 107 #endif
 108 #endif
 109 #endif /* not 4.1 bsd */
 110
 111 #ifdef BROKEN_FASYNC
 112 /* On some systems (DGUX comes to mind real fast) FASYNC causes
 113    background writes to the terminal to stop all processes in the
 114    process group when invoked under the csh (and probably any shell
 115    with job control). This stops Emacs dead in its tracks when coming
 116    up under X11. */
 117 #undef FASYNC
 118 #endif
 119
 120 #ifndef MSDOS
 121 #include <sys/ioctl.h>
 122 #endif
 123 #include "systty.h"
 124 #include "syswait.h"
 125
 126 #ifdef BROKEN_TIOCGWINSZ
 127 #undef TIOCGWINSZ
 128 #endif
 129
 130 #ifdef USG
 131 #include <sys/utsname.h>
 132 #include <string.h>
 133 #ifndef MEMORY_IN_STRING_H
 134 #include <memory.h>
 135 #endif
 136 #ifdef TIOCGWINSZ
 137 #ifdef NEED_SIOCTL
 138 #include <sys/sioctl.h>
 139 #endif
 140 #ifdef NEED_PTEM_H
 141 #include <sys/stream.h>
 142 #include <sys/ptem.h>
 143 #endif
 144 #endif /* TIOCGWINSZ */
 145 #endif /* USG */
 146
 147 extern int quit_char;
 148
 149 #include "frame.h"
 150 #include "window.h"
 151 #include "termhooks.h"
 152 #include "termchar.h"
 153 #include "termopts.h"
 154 #include "dispextern.h"
 155 #include "process.h"
 156
 157 #ifdef NONSYSTEM_DIR_LIBRARY
 158 #include "ndir.h"
 159 #endif /* NONSYSTEM_DIR_LIBRARY */
 160
 161 #include "syssignal.h"
 162 #include "systime.h"
 163
 164 /* LPASS8 is new in 4.3, and makes cbreak mode provide all 8 bits.  */
 165 #ifndef LPASS8
 166 #define LPASS8 0
 167 #endif
 168
 169 #ifdef BSD4_1
 170 #define LNOFLSH 0100000
 171 #endif
 172
 173 static int baud_convert[] =
 174 #ifdef BAUD_CONVERT
 175   BAUD_CONVERT;
 176 #else
 177   {
 178     0, 50, 75, 110, 135, 150, 200, 300, 600, 1200,
 179     1800, 2400, 4800, 9600, 19200, 38400
 180   };
 181 #endif
 182
 183 extern short ospeed;
 184
 185 /* The file descriptor for Emacs's input terminal.
 186    Under Unix, this is normaly zero except when using X;
 187    under VMS, we place the input channel number here.
 188    This allows us to write more code that works for both VMS and Unix.  */
 189 static int input_fd;
 190 \f
 191 /* Specify a different file descriptor for further input operations.  */
 192
 193 void
 194 change_input_fd (fd)
 195      int fd;
 196 {
 197   input_fd = fd;
 198 }
 199
 200 /* Discard pending input on descriptor input_fd.  */
 201
 202 discard_tty_input ()
 203 {
 204   struct emacs_tty buf;
 205
 206   if (noninteractive)
 207     return;
 208
 209   /* Discarding input is not safe when the input could contain
 210      replies from the X server.  So don't do it.  */
 211   if (read_socket_hook)
 212     return;
 213
 214 #ifdef VMS
 215   end_kbd_input ();
 216   SYS$QIOW (0, input_fd, IO$_READVBLK|IO$M_PURGE, input_iosb, 0, 0,
 217             &buf.main, 0, 0, terminator_mask, 0, 0);
 218   queue_kbd_input ();
 219 #else /* not VMS */
 220 #ifdef APOLLO
 221   {
 222     int zero = 0;
 223     ioctl (input_fd, TIOCFLUSH, &zero);
 224   }
 225 #else /* not Apollo */
 226 #ifdef MSDOS    /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
 227   while (dos_keyread () != -1)
 228         ;
 229 #else /* not MSDOS */
 230   EMACS_GET_TTY (input_fd, &buf);
 231   EMACS_SET_TTY (input_fd, &buf, 0);
 232 #endif /* not MSDOS */
 233 #endif /* not Apollo */
 234 #endif /* not VMS */
 235 }
 236
 237 #ifdef SIGTSTP
 238
 239 /* Arrange for character C to be read as the next input from
 240    the terminal.  */
 241
 242 stuff_char (c)
 243      char c;
 244 {
 245 /* Should perhaps error if in batch mode */
 246 #ifdef TIOCSTI
 247   ioctl (input_fd, TIOCSTI, &c);
 248 #else /* no TIOCSTI */
 249   error ("Cannot stuff terminal input characters in this version of Unix");
 250 #endif /* no TIOCSTI */
 251 }
 252
 253 #endif /* SIGTSTP */
 254 \f
 255 init_baud_rate ()
 256 {
 257   if (noninteractive)
 258     ospeed = 0;
 259   else
 260     {
 261 #ifdef MSDOS
 262     ospeed = 15;
 263 #else
 264 #ifdef VMS
 265       struct sensemode sg;
 266
 267       SYS$QIOW (0, input_fd, IO$_SENSEMODE, &sg, 0, 0,
 268                 &sg.class, 12, 0, 0, 0, 0 );
 269       ospeed = sg.xmit_baud;
 270 #else /* not VMS */
 271 #ifdef HAVE_TERMIOS
 272       struct termios sg;
 273
 274       sg.c_cflag = B9600;
 275       tcgetattr (input_fd, &sg);
 276       ospeed = cfgetospeed (&sg);
 277 #else /* neither VMS nor TERMIOS */
 278 #ifdef HAVE_TERMIO
 279       struct termio sg;
 280
 281       sg.c_cflag = B9600;
 282 #ifdef HAVE_TCATTR
 283       tcgetattr (input_fd, &sg);
 284 #else
 285       ioctl (input_fd, TCGETA, &sg);
 286 #endif
 287       ospeed = sg.c_cflag & CBAUD;
 288 #else /* neither VMS nor TERMIOS nor TERMIO */
 289       struct sgttyb sg;
 290
 291       sg.sg_ospeed = B9600;
 292       if (ioctl (input_fd, TIOCGETP, &sg) < 0)
 293         abort ();
 294       ospeed = sg.sg_ospeed;
 295 #endif /* not HAVE_TERMIO */
 296 #endif /* not HAVE_TERMIOS */
 297 #endif /* not VMS */
 298 #endif /* not MSDOS */
 299     }
 300
 301   baud_rate = (ospeed < sizeof baud_convert / sizeof baud_convert[0]
 302                ? baud_convert[ospeed] : 9600);
 303   if (baud_rate == 0)
 304     baud_rate = 1200;
 305 }
 306
 307 /*ARGSUSED*/
 308 set_exclusive_use (fd)
 309      int fd;
 310 {
 311 #ifdef FIOCLEX
 312   ioctl (fd, FIOCLEX, 0);
 313 #endif
 314   /* Ok to do nothing if this feature does not exist */
 315 }
 316 \f
 317 #ifndef subprocesses
 318
 319 wait_without_blocking ()
 320 {
 321 #ifdef BSD
 322   wait3 (0, WNOHANG | WUNTRACED, 0);
 323 #else
 324   croak ("wait_without_blocking");
 325 #endif
 326   synch_process_alive = 0;
 327 }
 328
 329 #endif /* not subprocesses */
 330
 331 int wait_debugging;   /* Set nonzero to make following function work under dbx
 332                          (at least for bsd).  */
 333
 334 SIGTYPE
 335 wait_for_termination_signal ()
 336 {}
 337
 338 /* Wait for subprocess with process id `pid' to terminate and
 339    make sure it will get eliminated (not remain forever as a zombie) */
 340
 341 wait_for_termination (pid)
 342      int pid;
 343 {
 344   while (1)
 345     {
 346 #ifdef subprocesses
 347 #ifdef VMS
 348       int status;
 349
 350       status = SYS$FORCEX (&pid, 0, 0);
 351       break;
 352 #else /* not VMS */
 353 #if defined (BSD) || (defined (HPUX) && !defined (HPUX_5))
 354       /* Note that kill returns -1 even if the process is just a zombie now.
 355          But inevitably a SIGCHLD interrupt should be generated
 356          and child_sig will do wait3 and make the process go away. */
 357       /* There is some indication that there is a bug involved with
 358          termination of subprocesses, perhaps involving a kernel bug too,
 359          but no idea what it is.  Just as a hunch we signal SIGCHLD to see
 360          if that causes the problem to go away or get worse.  */
 361       sigsetmask (sigmask (SIGCHLD));
 362       if (0 > kill (pid, 0))
 363         {
 364           sigsetmask (SIGEMPTYMASK);
 365           kill (getpid (), SIGCHLD);
 366           break;
 367         }
 368       if (wait_debugging)
 369         sleep (1);
 370       else
 371         sigpause (SIGEMPTYMASK);
 372 #else /* not BSD, and not HPUX version >= 6 */
 373 #if defined (UNIPLUS)
 374       if (0 > kill (pid, 0))
 375         break;
 376       wait (0);
 377 #else /* neither BSD nor UNIPLUS: random sysV */
 378 #ifdef POSIX_SIGNALS    /* would this work for LINUX as well? */
 379       sigblock (sigmask (SIGCHLD));
 380       if (0 > kill (pid, 0))
 381         {
 382           sigunblock (sigmask (SIGCHLD));
 383           break;
 384         }
 385       sigpause (SIGEMPTYMASK);
 386 #else /* not POSIX_SIGNALS */
 387 #ifdef HAVE_SYSV_SIGPAUSE
 388       sighold (SIGCHLD);
 389       if (0 > kill (pid, 0))
 390         {
 391           sigrelse (SIGCHLD);
 392           break;
 393         }
 394       sigpause (SIGCHLD);
 395 #else /* not HAVE_SYSV_SIGPAUSE */
 396       if (0 > kill (pid, 0))
 397         break;
 398       /* Using sleep instead of pause avoids timing error.
 399          If the inferior dies just before the sleep,
 400          we lose just one second.  */
 401       sleep (1);
 402 #endif /* not HAVE_SYSV_SIGPAUSE */
 403 #endif /* not POSIX_SIGNALS */
 404 #endif /* not UNIPLUS */
 405 #endif /* not BSD, and not HPUX version >= 6 */
 406 #endif /* not VMS */
 407 #else /* not subprocesses */
 408 #ifndef BSD4_1
 409       if (kill (pid, 0) < 0)
 410         break;
 411       wait (0);
 412 #else /* BSD4_1 */
 413       int status;
 414       status = wait (0);
 415       if (status == pid || status == -1)
 416         break;
 417 #endif /* BSD4_1 */
 418 #endif /* not subprocesses */
 419     }
 420 }
 421
 422 #ifdef subprocesses
 423
 424 /*
 425  *      flush any pending output
 426  *      (may flush input as well; it does not matter the way we use it)
 427  */
 428
 429 flush_pending_output (channel)
 430      int channel;
 431 {
 432 #ifdef HAVE_TERMIOS
 433   /* If we try this, we get hit with SIGTTIN, because
 434      the child's tty belongs to the child's pgrp. */
 435 #else
 436 #ifdef TCFLSH
 437   ioctl (channel, TCFLSH, 1);
 438 #else
 439 #ifdef TIOCFLUSH
 440   int zero = 0;
 441   /* 3rd arg should be ignored
 442      but some 4.2 kernels actually want the address of an int
 443      and nonzero means something different.  */
 444   ioctl (channel, TIOCFLUSH, &zero);
 445 #endif
 446 #endif
 447 #endif
 448 }
 449 \f
 450 #ifndef VMS
 451 /*  Set up the terminal at the other end of a pseudo-terminal that
 452     we will be controlling an inferior through.
 453     It should not echo or do line-editing, since that is done
 454     in Emacs.  No padding needed for insertion into an Emacs buffer.  */
 455
 456 child_setup_tty (out)
 457      int out;
 458 {
 459 #ifndef MSDOS
 460   struct emacs_tty s;
 461
 462   EMACS_GET_TTY (out, &s);
 463
 464 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
 465   s.main.c_oflag |= OPOST;      /* Enable output postprocessing */
 466   s.main.c_oflag &= ~ONLCR;     /* Disable map of NL to CR-NL on output */
 467 #ifdef NLDLY
 468   s.main.c_oflag &= ~(NLDLY|CRDLY|TABDLY|BSDLY|VTDLY|FFDLY);
 469                                 /* No output delays */
 470 #endif
 471   s.main.c_lflag &= ~ECHO;      /* Disable echo */
 472   s.main.c_lflag |= ISIG;       /* Enable signals */
 473 #ifdef IUCLC
 474   s.main.c_iflag &= ~IUCLC;     /* Disable downcasing on input.  */
 475 #endif
 476 #ifdef OLCUC
 477   s.main.c_oflag &= ~OLCUC;     /* Disable upcasing on output.  */
 478 #endif
 479   s.main.c_cflag = (s.main.c_cflag & ~CSIZE) | CS8; /* Don't strip 8th bit */
 480 #if 0
 481   /* Said to be unnecessary:  */
 482   s.main.c_cc[VMIN] = 1;        /* minimum number of characters to accept  */
 483   s.main.c_cc[VTIME] = 0;       /* wait forever for at least 1 character  */
 484 #endif
 485
 486   s.main.c_lflag |= ICANON;     /* Enable erase/kill and eof processing */
 487   s.main.c_cc[VEOF] = 04;       /* insure that EOF is Control-D */
 488   s.main.c_cc[VERASE] = 0377;   /* disable erase processing */
 489   s.main.c_cc[VKILL] = 0377;    /* disable kill processing */
 490
 491 #ifdef HPUX
 492   s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
 493 #endif /* HPUX */
 494
 495 #ifdef AIX
 496 /* AIX enhanced edit loses NULs, so disable it */
 497 #ifndef IBMR2AIX
 498   s.main.c_line = 0;
 499   s.main.c_iflag &= ~ASCEDIT;
 500 #endif
 501   /* Also, PTY overloads NUL and BREAK.
 502      don't ignore break, but don't signal either, so it looks like NUL.  */
 503   s.main.c_iflag &= ~IGNBRK;
 504   s.main.c_iflag &= ~BRKINT;
 505   /* QUIT and INTR work better as signals, so disable character forms */
 506   s.main.c_cc[VINTR] = 0377;
 507 #ifdef SIGNALS_VIA_CHARACTERS
 508   /* the QUIT and INTR character are used in process_send_signal
 509      so set them here to something useful.  */
 510   if (s.main.c_cc[VQUIT] == 0377)
 511     s.main.c_cc[VQUIT] = '\\'&037;      /* Control-\ */
 512   if (s.main.c_cc[VINTR] == 0377)
 513     s.main.c_cc[VINTR] = 'C'&037;       /* Control-C */
 514 #else /* no TIOCGPGRP or no TIOCGLTC or no TIOCGETC */
 515   /* QUIT and INTR work better as signals, so disable character forms */
 516   s.main.c_cc[VQUIT] = 0377;
 517   s.main.c_cc[VINTR] = 0377;
 518   s.main.c_lflag &= ~ISIG;
 519 #endif /* no TIOCGPGRP or no TIOCGLTC or no TIOCGETC */
 520   s.main.c_cc[VEOL] = 0377;
 521   s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
 522 #endif /* AIX */
 523
 524 #else /* not HAVE_TERMIO */
 525
 526   s.main.sg_flags &= ~(ECHO | CRMOD | ANYP | ALLDELAY | RAW | LCASE
 527                        | CBREAK | TANDEM);
 528   s.main.sg_flags |= LPASS8;
 529   s.main.sg_erase = 0377;
 530   s.main.sg_kill = 0377;
 531   s.lmode = LLITOUT | s.lmode;        /* Don't strip 8th bit */
 532
 533 #endif /* not HAVE_TERMIO */
 534
 535   EMACS_SET_TTY (out, &s, 0);
 536
 537 #ifdef BSD4_1
 538   if (interrupt_input)
 539     reset_sigio ();
 540 #endif /* BSD4_1 */
 541 #ifdef RTU
 542   {
 543     int zero = 0;
 544     ioctl (out, FIOASYNC, &zero);
 545   }
 546 #endif /* RTU */
 547 #endif /* not MSDOS */
 548 }
 549 #endif /* not VMS */
 550
 551 #endif /* subprocesses */
 552
 553 /*ARGSUSED*/
 554 setpgrp_of_tty (pid)
 555      int pid;
 556 {
 557   EMACS_SET_TTY_PGRP (input_fd, &pid);
 558 }
 559 \f
 560 /* Record a signal code and the handler for it.  */
 561 struct save_signal
 562 {
 563   int code;
 564   SIGTYPE (*handler) ();
 565 };
 566
 567 /* Suspend the Emacs process; give terminal to its superior.  */
 568
 569 sys_suspend ()
 570 {
 571 #ifdef MSDOS    /* Demacs 1.1.2 91/10/20 Manabu Higashida */
 572   int st;
 573   char oldwd[MAXPATHLEN+1]; /* Fixed length is safe on MSDOS.  */
 574 #endif
 575 #ifdef VMS
 576   /* "Foster" parentage allows emacs to return to a subprocess that attached
 577      to the current emacs as a cheaper than starting a whole new process.  This
 578      is set up by KEPTEDITOR.COM.  */
 579   unsigned long parent_id, foster_parent_id;
 580   char *fpid_string;
 581
 582   fpid_string = getenv ("EMACS_PARENT_PID");
 583   if (fpid_string != NULL)
 584     {
 585       sscanf (fpid_string, "%x", &foster_parent_id);
 586       if (foster_parent_id != 0)
 587         parent_id = foster_parent_id;
 588       else
 589         parent_id = getppid ();
 590     }
 591   else
 592     parent_id = getppid ();
 593
 594   xfree (fpid_string);          /* On VMS, this was malloc'd */
 595
 596   if (parent_id && parent_id != 0xffffffff)
 597     {
 598       SIGTYPE (*oldsig)() = (int) signal (SIGINT, SIG_IGN);
 599       int status = LIB$ATTACH (&parent_id) & 1;
 600       signal (SIGINT, oldsig);
 601       return status;
 602     }
 603   else
 604     {
 605       struct {
 606         int     l;
 607         char    *a;
 608       } d_prompt;
 609       d_prompt.l = sizeof ("Emacs: ");          /* Our special prompt */
 610       d_prompt.a = "Emacs: ";                   /* Just a reminder */
 611       LIB$SPAWN (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, &d_prompt, 0);
 612       return 1;
 613     }
 614   return -1;
 615 #else
 616 #if defined(SIGTSTP) && !defined(MSDOS)
 617
 618   {
 619     int pgrp = EMACS_GETPGRP (0);
 620     EMACS_KILLPG (pgrp, SIGTSTP);
 621   }
 622
 623 #else /* No SIGTSTP */
 624 #ifdef USG_JOBCTRL /* If you don't know what this is don't mess with it */
 625   ptrace (0, 0, 0, 0);          /* set for ptrace - caught by csh */
 626   kill (getpid (), SIGQUIT);
 627
 628 #else /* No SIGTSTP or USG_JOBCTRL */
 629
 630 /* On a system where suspending is not implemented,
 631    instead fork a subshell and let it talk directly to the terminal
 632    while we wait.  */
 633   int pid = fork ();
 634   struct save_signal saved_handlers[5];
 635
 636   saved_handlers[0].code = SIGINT;
 637   saved_handlers[1].code = SIGQUIT;
 638   saved_handlers[2].code = SIGTERM;
 639 #ifdef SIGIO
 640   saved_handlers[3].code = SIGIO;
 641   saved_handlers[4].code = 0;
 642 #else
 643   saved_handlers[3].code = 0;
 644 #endif
 645
 646   if (pid == -1)
 647     error ("Can't spawn subshell");
 648   if (pid == 0)
 649     {
 650       char *sh;
 651
 652 #ifdef MSDOS    /* MW, Aug 1993 */
 653       getwd (oldwd);
 654 #endif
 655       sh = (char *) egetenv ("SHELL");
 656       if (sh == 0)
 657         sh = "sh";
 658
 659       /* Use our buffer's default directory for the subshell.  */
 660       {
 661         Lisp_Object dir;
 662         unsigned char *str;
 663         int len;
 664
 665         /* mentioning current_buffer->buffer would mean including buffer.h,
 666            which somehow wedges the hp compiler.  So instead... */
 667
 668         dir = intern ("default-directory");
 669         /* Can't use NILP */
 670         if (XFASTINT (Fboundp (dir)) == XFASTINT (Qnil))
 671           goto xyzzy;
 672         dir = Fsymbol_value (dir);
 673         if (XTYPE (dir) != Lisp_String)
 674           goto xyzzy;
 675
 676         str = (unsigned char *) alloca (XSTRING (dir)->size + 2);
 677         len = XSTRING (dir)->size;
 678         bcopy (XSTRING (dir)->data, str, len);
 679         if (str[len - 1] != '/') str[len++] = '/';
 680         str[len] = 0;
 681         chdir (str);
 682       }
 683     xyzzy:
 684 #ifdef subprocesses
 685       close_process_descs ();   /* Close Emacs's pipes/ptys */
 686 #endif
 687
 688 #ifdef PRIO_PROCESS
 689       {
 690         extern int emacs_priority;
 691
 692         if (emacs_priority)
 693           nice (-emacs_priority);
 694       }
 695 #endif
 696
 697 #ifdef MSDOS    /* Demacs 1.1.2 91/10/20 Manabu Higashida */
 698       st = system (sh);
 699       chdir (oldwd);
 700       if (st)
 701         report_file_error ("Can't execute subshell", Fcons (build_string (sh), Qnil));
 702 #else /* not MSDOS */
 703       execlp (sh, sh, 0);
 704       write (1, "Can't execute subshell", 22);
 705       _exit (1);
 706 #endif /* not MSDOS */
 707     }
 708
 709   save_signal_handlers (saved_handlers);
 710   synch_process_alive = 1;
 711   wait_for_termination (pid);
 712   restore_signal_handlers (saved_handlers);
 713
 714 #endif /* no USG_JOBCTRL */
 715 #endif /* no SIGTSTP */
 716 #endif /* not VMS */
 717 }
 718
 719 save_signal_handlers (saved_handlers)
 720      struct save_signal *saved_handlers;
 721 {
 722   while (saved_handlers->code)
 723     {
 724       saved_handlers->handler
 725         = (SIGTYPE (*) ()) signal (saved_handlers->code, SIG_IGN);
 726       saved_handlers++;
 727     }
 728 }
 729
 730 restore_signal_handlers (saved_handlers)
 731      struct save_signal *saved_handlers;
 732 {
 733   while (saved_handlers->code)
 734     {
 735       signal (saved_handlers->code, saved_handlers->handler);
 736       saved_handlers++;
 737     }
 738 }
 739 \f
 740 #ifdef F_SETFL
 741
 742 int old_fcntl_flags;
 743
 744 init_sigio ()
 745 {
 746 #ifdef FASYNC
 747   old_fcntl_flags = fcntl (input_fd, F_GETFL, 0) & ~FASYNC;
 748 #endif
 749   request_sigio ();
 750 }
 751
 752 reset_sigio ()
 753 {
 754   unrequest_sigio ();
 755 }
 756
 757 #ifdef FASYNC           /* F_SETFL does not imply existence of FASYNC */
 758
 759 request_sigio ()
 760 {
 761 #ifdef SIGWINCH
 762   sigunblock (sigmask (SIGWINCH));
 763 #endif
 764   fcntl (input_fd, F_SETFL, old_fcntl_flags | FASYNC);
 765
 766   interrupts_deferred = 0;
 767 }
 768
 769 unrequest_sigio ()
 770 {
 771 #ifdef SIGWINCH
 772   sigblock (sigmask (SIGWINCH));
 773 #endif
 774   fcntl (input_fd, F_SETFL, old_fcntl_flags);
 775   interrupts_deferred = 1;
 776 }
 777
 778 #else /* no FASYNC */
 779 #ifdef STRIDE           /* Stride doesn't have FASYNC - use FIOASYNC */
 780
 781 request_sigio ()
 782 {
 783   int on = 1;
 784   ioctl (input_fd, FIOASYNC, &on);
 785   interrupts_deferred = 0;
 786 }
 787
 788 unrequest_sigio ()
 789 {
 790   int off = 0;
 791
 792   ioctl (input_fd, FIOASYNC, &off);
 793   interrupts_deferred = 1;
 794 }
 795
 796 #else /* not FASYNC, not STRIDE */
 797
 798 #ifdef _CX_UX
 799
 800 #include <termios.h>
 801
 802 request_sigio ()
 803 {
 804   int on = 1;
 805   sigset_t st;
 806
 807   sigemptyset(&st);
 808   sigaddset(&st, SIGIO);
 809   ioctl (input_fd, FIOASYNC, &on);
 810   interrupts_deferred = 0;
 811   sigprocmask(SIG_UNBLOCK, &st, (sigset_t *)0);
 812 }
 813
 814 unrequest_sigio ()
 815 {
 816   int off = 0;
 817
 818   ioctl (input_fd, FIOASYNC, &off);
 819   interrupts_deferred = 1;
 820 }
 821
 822 #else /* ! _CX_UX */
 823
 824 request_sigio ()
 825 {
 826   croak ("request_sigio");
 827 }
 828
 829 unrequest_sigio ()
 830 {
 831   croak ("unrequest_sigio");
 832 }
 833
 834 #endif /* _CX_UX */
 835 #endif /* STRIDE */
 836 #endif /* FASYNC */
 837 #endif /* F_SETFL */
 838 \f
 839 /* Saving and restoring the process group of Emacs's terminal.  */
 840
 841 #ifdef BSD_PGRPS
 842
 843 /* The process group of which Emacs was a member when it initially
 844    started.
 845
 846    If Emacs was in its own process group (i.e. inherited_pgroup ==
 847    getpid ()), then we know we're running under a shell with job
 848    control (Emacs would never be run as part of a pipeline).
 849    Everything is fine.
 850
 851    If Emacs was not in its own process group, then we know we're
 852    running under a shell (or a caller) that doesn't know how to
 853    separate itself from Emacs (like sh).  Emacs must be in its own
 854    process group in order to receive SIGIO correctly.  In this
 855    situation, we put ourselves in our own pgroup, forcibly set the
 856    tty's pgroup to our pgroup, and make sure to restore and reinstate
 857    the tty's pgroup just like any other terminal setting.  If
 858    inherited_group was not the tty's pgroup, then we'll get a
 859    SIGTTmumble when we try to change the tty's pgroup, and a CONT if
 860    it goes foreground in the future, which is what should happen.  */
 861 int inherited_pgroup;
 862
 863 /* Split off the foreground process group to Emacs alone.
 864    When we are in the foreground, but not started in our own process
 865    group, redirect the TTY to point to our own process group.  We need
 866    to be in our own process group to receive SIGIO properly.  */
 867 narrow_foreground_group ()
 868 {
 869   int me = getpid ();
 870
 871   setpgrp (0, inherited_pgroup);
 872   if (inherited_pgroup != me)
 873     EMACS_SET_TTY_PGRP (input_fd, &me);
 874   setpgrp (0, me);
 875 }
 876
 877 /* Set the tty to our original foreground group.  */
 878 widen_foreground_group ()
 879 {
 880   if (inherited_pgroup != getpid ())
 881     EMACS_SET_TTY_PGRP (input_fd, &inherited_pgroup);
 882   setpgrp (0, inherited_pgroup);
 883 }
 884
 885 #endif /* BSD_PGRPS */
 886 \f
 887 /* Getting and setting emacs_tty structures.  */
 888
 889 /* Set *TC to the parameters associated with the terminal FD.
 890    Return zero if all's well, or -1 if we ran into an error we
 891    couldn't deal with.  */
 892 int
 893 emacs_get_tty (fd, settings)
 894      int fd;
 895      struct emacs_tty *settings;
 896 {
 897   /* Retrieve the primary parameters - baud rate, character size, etcetera.  */
 898 #ifdef HAVE_TCATTR
 899   /* We have those nifty POSIX tcmumbleattr functions.  */
 900   if (tcgetattr (fd, &settings->main) < 0)
 901     return -1;
 902
 903 #else
 904 #ifdef HAVE_TERMIO
 905   /* The SYSV-style interface?  */
 906   if (ioctl (fd, TCGETA, &settings->main) < 0)
 907     return -1;
 908
 909 #else
 910 #ifdef VMS
 911   /* Vehemently Monstrous System?  :-)  */
 912   if (! (SYS$QIOW (0, fd, IO$_SENSEMODE, settings, 0, 0,
 913                    &settings->main.class, 12, 0, 0, 0, 0)
 914          & 1))
 915     return -1;
 916
 917 #else
 918 #ifndef MSDOS
 919   /* I give up - I hope you have the BSD ioctls.  */
 920   if (ioctl (fd, TIOCGETP, &settings->main) < 0)
 921     return -1;
 922 #endif /* not MSDOS */
 923 #endif
 924 #endif
 925 #endif
 926
 927   /* Suivant - Do we have to get struct ltchars data?  */
 928 #ifdef HAVE_LTCHARS
 929   if (ioctl (fd, TIOCGLTC, &settings->ltchars) < 0)
 930     return -1;
 931 #endif
 932
 933   /* How about a struct tchars and a wordful of lmode bits?  */
 934 #ifdef HAVE_TCHARS
 935   if (ioctl (fd, TIOCGETC, &settings->tchars) < 0
 936       || ioctl (fd, TIOCLGET, &settings->lmode) < 0)
 937     return -1;
 938 #endif
 939
 940   /* We have survived the tempest.  */
 941   return 0;
 942 }
 943
 944
 945 /* Set the parameters of the tty on FD according to the contents of
 946    *SETTINGS.  If WAITP is non-zero, we wait for all queued output to
 947    be written before making the change; otherwise, we forget any
 948    queued input and make the change immediately.
 949    Return 0 if all went well, and -1 if anything failed.  */
 950 int
 951 emacs_set_tty (fd, settings, waitp)
 952      int fd;
 953      struct emacs_tty *settings;
 954      int waitp;
 955 {
 956   /* Set the primary parameters - baud rate, character size, etcetera.  */
 957 #ifdef HAVE_TCATTR
 958   int i;
 959   /* We have those nifty POSIX tcmumbleattr functions.
 960      William J. Smith <wjs@wiis.wang.com> writes:
 961      "POSIX 1003.1 defines tcsetattr() to return success if it was
 962      able to perform any of the requested actions, even if some
 963      of the requested actions could not be performed.
 964      We must read settings back to ensure tty setup properly.
 965      AIX requires this to keep tty from hanging occasionally."  */
 966   /* This make sure that we don't loop indefinitely in here.  */
 967   for (i = 0 ; i < 10 ; i++)
 968     if (tcsetattr (fd, waitp ? TCSAFLUSH : TCSADRAIN, &settings->main) < 0)
 969       {
 970         if (errno == EINTR)
 971           continue;
 972         else
 973           return -1;
 974       }
 975     else
 976       {
 977         struct termios new;
 978
 979         /* Get the current settings, and see if they're what we asked for.  */
 980         tcgetattr (fd, &new);
 981         /* We cannot use memcmp on the whole structure here because under
 982          * aix386 the termios structure has some reserved field that may
 983          * not be filled in.
 984          */
 985         if (   new.c_iflag == settings->main.c_iflag
 986             && new.c_oflag == settings->main.c_oflag
 987             && new.c_cflag == settings->main.c_cflag
 988             && new.c_lflag == settings->main.c_lflag
 989             && memcmp(new.c_cc, settings->main.c_cc, NCCS) == 0)
 990           break;
 991         else
 992           continue;
 993       }
 994
 995 #else
 996 #ifdef HAVE_TERMIO
 997   /* The SYSV-style interface?  */
 998   if (ioctl (fd, waitp ? TCSETAW : TCSETAF, &settings->main) < 0)
 999     return -1;
1000
1001 #else
1002 #ifdef VMS
1003   /* Vehemently Monstrous System?  :-)  */
1004   if (! (SYS$QIOW (0, fd, IO$_SETMODE, &input_iosb, 0, 0,
1005                    &settings->main.class, 12, 0, 0, 0, 0)
1006          & 1))
1007     return -1;
1008
1009 #else
1010 #ifndef MSDOS
1011   /* I give up - I hope you have the BSD ioctls.  */
1012   if (ioctl (fd, (waitp) ? TIOCSETP : TIOCSETN, &settings->main) < 0)
1013     return -1;
1014 #endif /* not MSDOS */
1015
1016 #endif
1017 #endif
1018 #endif
1019
1020   /* Suivant - Do we have to get struct ltchars data?  */
1021 #ifdef HAVE_LTCHARS
1022   if (ioctl (fd, TIOCSLTC, &settings->ltchars) < 0)
1023     return -1;
1024 #endif
1025
1026   /* How about a struct tchars and a wordful of lmode bits?  */
1027 #ifdef HAVE_TCHARS
1028   if (ioctl (fd, TIOCSETC, &settings->tchars) < 0
1029       || ioctl (fd, TIOCLSET, &settings->lmode) < 0)
1030     return -1;
1031 #endif
1032
1033   /* We have survived the tempest.  */
1034   return 0;
1035 }
1036
1037 \f
1038 /* The initial tty mode bits */
1039 struct emacs_tty old_tty;
1040
1041 int term_initted;               /* 1 if outer tty status has been recorded */
1042
1043 #ifdef BSD4_1
1044 /* BSD 4.1 needs to keep track of the lmode bits in order to start
1045    sigio.  */
1046 int lmode;
1047 #endif
1048
1049 #ifndef F_SETOWN_BUG
1050 #ifdef F_SETOWN
1051 int old_fcntl_owner;
1052 #endif /* F_SETOWN */
1053 #endif /* F_SETOWN_BUG */
1054
1055 /* This may also be defined in stdio,
1056    but if so, this does no harm,
1057    and using the same name avoids wasting the other one's space.  */
1058
1059 #if defined (USG) || defined (DGUX)
1060 unsigned char _sobuf[BUFSIZ+8];
1061 #else
1062 char _sobuf[BUFSIZ];
1063 #endif
1064
1065 #ifdef HAVE_LTCHARS
1066 static struct ltchars new_ltchars = {-1,-1,-1,-1,-1,-1};
1067 #endif
1068 #ifdef HAVE_TCHARS
1069   static struct tchars new_tchars = {-1,-1,-1,-1,-1,-1};
1070 #endif
1071
1072 init_sys_modes ()
1073 {
1074   struct emacs_tty tty;
1075
1076 #ifdef VMS
1077 #if 0
1078   static int oob_chars[2] = {0, 1 << 7}; /* catch C-g's */
1079   extern int (*interrupt_signal) ();
1080 #endif
1081 #endif
1082
1083   if (noninteractive)
1084     return;
1085
1086 #ifdef VMS
1087   if (!input_ef)
1088     input_ef = get_kbd_event_flag ();
1089     /* LIB$GET_EF (&input_ef); */
1090   SYS$CLREF (input_ef);
1091   waiting_for_ast = 0;
1092   if (!timer_ef)
1093     timer_ef = get_timer_event_flag ();
1094     /* LIB$GET_EF (&timer_ef); */
1095   SYS$CLREF (timer_ef);
1096 #if 0
1097   if (!process_ef)
1098     {
1099       LIB$GET_EF (&process_ef);
1100       SYS$CLREF (process_ef);
1101     }
1102   if (input_ef / 32 != process_ef / 32)
1103     croak ("Input and process event flags in different clusters.");
1104 #endif
1105   if (input_ef / 32 != timer_ef / 32)
1106     croak ("Input and timer event flags in different clusters.");
1107 #if 0
1108   input_eflist = ((unsigned) 1 << (input_ef % 32)) |
1109     ((unsigned) 1 << (process_ef % 32));
1110 #endif
1111   timer_eflist = ((unsigned) 1 << (input_ef % 32)) |
1112     ((unsigned) 1 << (timer_ef % 32));
1113 #ifndef VMS4_4
1114   sys_access_reinit ();
1115 #endif
1116 #endif /* not VMS */
1117
1118 #ifdef BSD_PGRPS
1119   if (! read_socket_hook && EQ (Vwindow_system, Qnil))
1120     narrow_foreground_group ();
1121 #endif
1122
1123   EMACS_GET_TTY (input_fd, &old_tty);
1124
1125   if (!read_socket_hook && EQ (Vwindow_system, Qnil))
1126     {
1127       tty = old_tty;
1128
1129 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
1130       tty.main.c_iflag |= (IGNBRK);     /* Ignore break condition */
1131       tty.main.c_iflag &= ~ICRNL;       /* Disable map of CR to NL on input */
1132 #ifdef ISTRIP
1133       tty.main.c_iflag &= ~ISTRIP;      /* don't strip 8th bit on input */
1134 #endif
1135       tty.main.c_lflag &= ~ECHO;        /* Disable echo */
1136       tty.main.c_lflag &= ~ICANON;      /* Disable erase/kill processing */
1137 #ifdef IEXTEN
1138       tty.main.c_lflag &= ~IEXTEN;      /* Disable other editing characters.  */
1139 #endif
1140       tty.main.c_lflag |= ISIG; /* Enable signals */
1141       if (flow_control)
1142         {
1143           tty.main.c_iflag |= IXON;     /* Enable start/stop output control */
1144 #ifdef IXANY
1145           tty.main.c_iflag &= ~IXANY;
1146 #endif /* IXANY */
1147         }
1148       else
1149         tty.main.c_iflag &= ~IXON;      /* Disable start/stop output control */
1150       tty.main.c_oflag &= ~ONLCR;       /* Disable map of NL to CR-NL
1151                                            on output */
1152       tty.main.c_oflag &= ~TAB3;        /* Disable tab expansion */
1153 #ifdef CS8
1154       if (meta_key)
1155         {
1156           tty.main.c_cflag |= CS8;      /* allow 8th bit on input */
1157           tty.main.c_cflag &= ~PARENB;/* Don't check parity */
1158         }
1159 #endif
1160       tty.main.c_cc[VINTR] = quit_char; /* C-g (usually) gives SIGINT */
1161       /* Set up C-g for both SIGQUIT and SIGINT.
1162          We don't know which we will get, but we handle both alike
1163          so which one it really gives us does not matter.  */
1164       tty.main.c_cc[VQUIT] = quit_char;
1165       tty.main.c_cc[VMIN] = 1;  /* Input should wait for at least 1 char */
1166       tty.main.c_cc[VTIME] = 0; /* no matter how long that takes.  */
1167 #ifdef VSWTCH
1168       tty.main.c_cc[VSWTCH] = CDISABLE; /* Turn off shell layering use
1169                                            of C-z */
1170 #endif /* VSWTCH */
1171 #if defined (mips) || defined (HAVE_TCATTR)
1172 #ifdef VSUSP
1173       tty.main.c_cc[VSUSP] = CDISABLE;  /* Turn off mips handling of C-z.  */
1174 #endif /* VSUSP */
1175 #ifdef V_DSUSP
1176       tty.main.c_cc[V_DSUSP] = CDISABLE; /* Turn off mips handling of C-y.  */
1177 #endif /* V_DSUSP */
1178 #ifdef VDSUSP /* Some systems have VDSUSP, some have V_DSUSP.  */
1179       tty.main.c_cc[VDSUSP] = CDISABLE;
1180 #endif /* VDSUSP */
1181 #ifdef VLNEXT
1182       tty.main.c_cc[VLNEXT] = CDISABLE;
1183 #endif /* VLNEXT */
1184 #ifdef VREPRINT
1185       tty.main.c_cc[VREPRINT] = CDISABLE;
1186 #endif /* VREPRINT */
1187 #ifdef VWERASE
1188       tty.main.c_cc[VWERASE] = CDISABLE;
1189 #endif /* VWERASE */
1190 #ifdef VDISCARD
1191       tty.main.c_cc[VDISCARD] = CDISABLE;
1192 #endif /* VDISCARD */
1193 #endif /* mips or HAVE_TCATTR */
1194 #ifdef AIX
1195 #ifndef IBMR2AIX
1196       /* AIX enhanced edit loses NULs, so disable it */
1197       tty.main.c_line = 0;
1198       tty.main.c_iflag &= ~ASCEDIT;
1199 #else
1200       tty.main.c_cc[VSTRT] = 255;
1201       tty.main.c_cc[VSTOP] = 255;
1202       tty.main.c_cc[VSUSP] = 255;
1203       tty.main.c_cc[VDSUSP] = 255;
1204 #endif /* IBMR2AIX */
1205       /* Also, PTY overloads NUL and BREAK.
1206          don't ignore break, but don't signal either, so it looks like NUL.
1207          This really serves a purpose only if running in an XTERM window
1208          or via TELNET or the like, but does no harm elsewhere.  */
1209       tty.main.c_iflag &= ~IGNBRK;
1210       tty.main.c_iflag &= ~BRKINT;
1211 #endif
1212 #else /* if not HAVE_TERMIO */
1213 #ifdef VMS
1214       tty.main.tt_char |= TT$M_NOECHO;
1215       if (meta_key)
1216         tty.main.tt_char |= TT$M_EIGHTBIT;
1217       if (flow_control)
1218         tty.main.tt_char |= TT$M_TTSYNC;
1219       else
1220         tty.main.tt_char &= ~TT$M_TTSYNC;
1221       tty.main.tt2_char |= TT2$M_PASTHRU | TT2$M_XON;
1222 #else /* not VMS (BSD, that is) */
1223 #ifndef MSDOS
1224       tty.main.sg_flags &= ~(ECHO | CRMOD | XTABS);
1225       if (meta_key)
1226         tty.main.sg_flags |= ANYP;
1227       tty.main.sg_flags |= interrupt_input ? RAW : CBREAK;
1228 #endif
1229 #endif /* not VMS (BSD, that is) */
1230 #endif /* not HAVE_TERMIO */
1231
1232       /* If going to use CBREAK mode, we must request C-g to interrupt
1233          and turn off start and stop chars, etc.  If not going to use
1234          CBREAK mode, do this anyway so as to turn off local flow
1235          control for user coming over network on 4.2; in this case,
1236          only t_stopc and t_startc really matter.  */
1237 #ifndef HAVE_TERMIO
1238 #ifdef HAVE_TCHARS
1239       /* Note: if not using CBREAK mode, it makes no difference how we
1240          set this */
1241       tty.tchars = new_tchars;
1242       tty.tchars.t_intrc = quit_char;
1243       if (flow_control)
1244         {
1245           tty.tchars.t_startc = '\021';
1246           tty.tchars.t_stopc = '\023';
1247         }
1248
1249       tty.lmode = LDECCTQ | LLITOUT | LPASS8 | LNOFLSH | old_tty.lmode;
1250 #ifdef ultrix
1251       /* Under Ultrix 4.2a, leaving this out doesn't seem to hurt
1252          anything, and leaving it in breaks the meta key.  Go figure.  */
1253       tty.lmode &= ~LLITOUT;
1254 #endif
1255
1256 #ifdef BSD4_1
1257       lmode = tty.lmode;
1258 #endif
1259
1260 #endif /* HAVE_TCHARS */
1261 #endif /* not HAVE_TERMIO */
1262
1263 #ifdef HAVE_LTCHARS
1264       tty.ltchars = new_ltchars;
1265 #endif /* HAVE_LTCHARS */
1266 #ifdef MSDOS    /* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
1267       internal_terminal_init ();
1268       dos_ttraw ();
1269 #endif
1270
1271       EMACS_SET_TTY (input_fd, &tty, 0);
1272
1273       /* This code added to insure that, if flow-control is not to be used,
1274          we have an unlocked terminal at the start. */
1275
1276 #ifdef TCXONC
1277       if (!flow_control) ioctl (input_fd, TCXONC, 1);
1278 #endif
1279 #ifndef APOLLO
1280 #ifdef TIOCSTART
1281       if (!flow_control) ioctl (input_fd, TIOCSTART, 0);
1282 #endif
1283 #endif
1284
1285 #ifdef AIX
1286       hft_init ();
1287 #ifdef IBMR2AIX
1288       {
1289         /* IBM's HFT device usually thinks a ^J should be LF/CR.  We need it
1290            to be only LF.  This is the way that is done. */
1291         struct termio tty;
1292
1293         if (ioctl (1, HFTGETID, &tty) != -1)
1294           write (1, "\033[20l", 5);
1295       }
1296 #endif
1297 #endif
1298
1299 #ifdef VMS
1300 /*  Appears to do nothing when in PASTHRU mode.
1301       SYS$QIOW (0, input_fd, IO$_SETMODE|IO$M_OUTBAND, 0, 0, 0,
1302                 interrupt_signal, oob_chars, 0, 0, 0, 0);
1303 */
1304       queue_kbd_input (0);
1305 #endif /* VMS */
1306     }
1307
1308 #ifdef F_SETFL
1309 #ifndef F_SETOWN_BUG
1310 #ifdef F_GETOWN         /* F_SETFL does not imply existence of F_GETOWN */
1311   if (interrupt_input)
1312     {
1313       old_fcntl_owner = fcntl (input_fd, F_GETOWN, 0);
1314       fcntl (input_fd, F_SETOWN, getpid ());
1315       init_sigio ();
1316     }
1317 #endif /* F_GETOWN */
1318 #endif /* F_SETOWN_BUG */
1319 #endif /* F_SETFL */
1320
1321 #ifdef BSD4_1
1322   if (interrupt_input)
1323     init_sigio ();
1324 #endif
1325
1326 #ifdef VMS  /* VMS sometimes has this symbol but lacks setvbuf.  */
1327 #undef _IOFBF
1328 #endif
1329 #ifdef _IOFBF
1330   /* This symbol is defined on recent USG systems.
1331      Someone says without this call USG won't really buffer the file
1332      even with a call to setbuf. */
1333   setvbuf (stdout, _sobuf, _IOFBF, sizeof _sobuf);
1334 #else
1335   setbuf (stdout, _sobuf);
1336 #endif
1337   set_terminal_modes ();
1338   if (term_initted && no_redraw_on_reenter)
1339     {
1340       if (display_completed)
1341         direct_output_forward_char (0);
1342     }
1343   else
1344     {
1345       frame_garbaged = 1;
1346 #ifdef MULTI_FRAME
1347       if (FRAMEP (Vterminal_frame))
1348         FRAME_GARBAGED_P (XFRAME (Vterminal_frame)) = 1;
1349 #endif
1350     }
1351
1352   term_initted = 1;
1353 }
1354
1355 /* Return nonzero if safe to use tabs in output.
1356    At the time this is called, init_sys_modes has not been done yet.  */
1357
1358 tabs_safe_p ()
1359 {
1360   struct emacs_tty tty;
1361
1362   EMACS_GET_TTY (input_fd, &tty);
1363   return EMACS_TTY_TABS_OK (&tty);
1364 }
1365
1366 /* Get terminal size from system.
1367    Store number of lines into *heightp and width into *widthp.
1368    If zero or a negative number is stored, the value is not valid.  */
1369
1370 get_frame_size (widthp, heightp)
1371      int *widthp, *heightp;
1372 {
1373
1374 #ifdef TIOCGWINSZ
1375
1376   /* BSD-style.  */
1377   struct winsize size;
1378
1379   if (ioctl (input_fd, TIOCGWINSZ, &size) == -1)
1380     *widthp = *heightp = 0;
1381   else
1382     {
1383       *widthp = size.ws_col;
1384       *heightp = size.ws_row;
1385     }
1386
1387 #else
1388 #ifdef TIOCGSIZE
1389
1390   /* SunOS - style.  */
1391   struct ttysize size;
1392
1393   if (ioctl (input_fd, TIOCGSIZE, &size) == -1)
1394     *widthp = *heightp = 0;
1395   else
1396     {
1397       *widthp = size.ts_cols;
1398       *heightp = size.ts_lines;
1399     }
1400
1401 #else
1402 #ifdef VMS
1403
1404   struct sensemode tty;
1405
1406   SYS$QIOW (0, input_fd, IO$_SENSEMODE, &tty, 0, 0,
1407             &tty.class, 12, 0, 0, 0, 0);
1408   *widthp = tty.scr_wid;
1409   *heightp = tty.scr_len;
1410
1411 #else
1412 #ifdef MSDOS
1413   *widthp = ScreenCols ();
1414   *heightp = ScreenRows ();
1415 #else /* system doesn't know size */
1416   *widthp = 0;
1417   *heightp = 0;
1418 #endif
1419
1420 #endif /* not VMS */
1421 #endif /* not SunOS-style */
1422 #endif /* not BSD-style */
1423 }
1424
1425 \f
1426 /* Prepare the terminal for exiting Emacs; move the cursor to the
1427    bottom of the frame, turn off interrupt-driven I/O, etc.  */
1428 reset_sys_modes ()
1429 {
1430   if (noninteractive)
1431     {
1432       fflush (stdout);
1433       return;
1434     }
1435   if (!term_initted)
1436     return;
1437   if (read_socket_hook || !EQ (Vwindow_system, Qnil))
1438     return;
1439   cursor_to (FRAME_HEIGHT (selected_frame) - 1, 0);
1440   clear_end_of_line (FRAME_WIDTH (selected_frame));
1441   /* clear_end_of_line may move the cursor */
1442   cursor_to (FRAME_HEIGHT (selected_frame) - 1, 0);
1443 #ifdef IBMR2AIX
1444   {
1445     /* HFT devices normally use ^J as a LF/CR.  We forced it to
1446        do the LF only.  Now, we need to reset it. */
1447     struct termio tty;
1448
1449     if (ioctl (1, HFTGETID, &tty) != -1)
1450       write (1, "\033[20h", 5);
1451   }
1452 #endif
1453
1454   reset_terminal_modes ();
1455   fflush (stdout);
1456 #ifdef BSD
1457 #ifndef BSD4_1
1458   /* Avoid possible loss of output when changing terminal modes.  */
1459   fsync (fileno (stdout));
1460 #endif
1461 #endif
1462
1463 #ifdef F_SETFL
1464 #ifndef F_SETOWN_BUG
1465 #ifdef F_SETOWN         /* F_SETFL does not imply existence of F_SETOWN */
1466   if (interrupt_input)
1467     {
1468       reset_sigio ();
1469       fcntl (input_fd, F_SETOWN, old_fcntl_owner);
1470     }
1471 #endif /* F_SETOWN */
1472 #endif /* F_SETOWN_BUG */
1473 #endif /* F_SETFL */
1474 #ifdef BSD4_1
1475   if (interrupt_input)
1476     reset_sigio ();
1477 #endif /* BSD4_1 */
1478
1479   while (EMACS_SET_TTY (input_fd, &old_tty, 0) < 0 && errno == EINTR)
1480     ;
1481
1482 #ifdef MSDOS    /* Demacs 1.1.2 91/10/20 Manabu Higashida */
1483   dos_ttcooked ();
1484 #endif
1485
1486 #ifdef AIX
1487   hft_reset ();
1488 #endif
1489
1490 #ifdef BSD_PGRPS
1491   widen_foreground_group ();
1492 #endif
1493 }
1494 \f
1495 #ifdef HAVE_PTYS
1496
1497 /* Set up the proper status flags for use of a pty.  */
1498
1499 setup_pty (fd)
1500      int fd;
1501 {
1502   /* I'm told that TOICREMOTE does not mean control chars
1503      "can't be sent" but rather that they don't have
1504      input-editing or signaling effects.
1505      That should be good, because we have other ways
1506      to do those things in Emacs.
1507      However, telnet mode seems not to work on 4.2.
1508      So TIOCREMOTE is turned off now. */
1509
1510   /* Under hp-ux, if TIOCREMOTE is turned on, some calls
1511      will hang.  In particular, the "timeout" feature (which
1512      causes a read to return if there is no data available)
1513      does this.  Also it is known that telnet mode will hang
1514      in such a way that Emacs must be stopped (perhaps this
1515      is the same problem).
1516
1517      If TIOCREMOTE is turned off, then there is a bug in
1518      hp-ux which sometimes loses data.  Apparently the
1519      code which blocks the master process when the internal
1520      buffer fills up does not work.  Other than this,
1521      though, everything else seems to work fine.
1522
1523      Since the latter lossage is more benign, we may as well
1524      lose that way.  -- cph */
1525 #ifdef FIONBIO
1526 #ifdef SYSV_PTYS
1527   {
1528     int on = 1;
1529     ioctl (fd, FIONBIO, &on);
1530   }
1531 #endif
1532 #endif
1533 #ifdef IBMRTAIX
1534   /* On AIX, the parent gets SIGHUP when a pty attached child dies.  So, we */
1535   /* ignore SIGHUP once we've started a child on a pty.  Note that this may */
1536   /* cause EMACS not to die when it should, i.e., when its own controlling  */
1537   /* tty goes away.  I've complained to the AIX developers, and they may    */
1538   /* change this behavior, but I'm not going to hold my breath.             */
1539   signal (SIGHUP, SIG_IGN);
1540 #endif
1541 }
1542 #endif /* HAVE_PTYS */
1543 \f
1544 #ifdef VMS
1545
1546 /* Assigning an input channel is done at the start of Emacs execution.
1547    This is called each time Emacs is resumed, also, but does nothing
1548    because input_chain is no longer zero.  */
1549
1550 init_vms_input ()
1551 {
1552   int status;
1553
1554   if (input_fd == 0)
1555     {
1556       status = SYS$ASSIGN (&input_dsc, &input_fd, 0, 0);
1557       if (! (status & 1))
1558         LIB$STOP (status);
1559     }
1560 }
1561
1562 /* Deassigning the input channel is done before exiting.  */
1563
1564 stop_vms_input ()
1565 {
1566   return SYS$DASSGN (input_fd);
1567 }
1568
1569 short input_buffer;
1570
1571 /* Request reading one character into the keyboard buffer.
1572    This is done as soon as the buffer becomes empty.  */
1573
1574 queue_kbd_input ()
1575 {
1576   int status;
1577   extern kbd_input_ast ();
1578
1579   waiting_for_ast = 0;
1580   stop_input = 0;
1581   status = SYS$QIO (0, input_fd, IO$_READVBLK,
1582                     &input_iosb, kbd_input_ast, 1,
1583                     &input_buffer, 1, 0, terminator_mask, 0, 0);
1584 }
1585
1586 int input_count;
1587
1588 /* Ast routine that is called when keyboard input comes in
1589    in accord with the SYS$QIO above.  */
1590
1591 kbd_input_ast ()
1592 {
1593   register int c = -1;
1594   int old_errno = errno;
1595   extern EMACS_TIME *input_available_clear_time;
1596
1597   if (waiting_for_ast)
1598     SYS$SETEF (input_ef);
1599   waiting_for_ast = 0;
1600   input_count++;
1601 #ifdef ASTDEBUG
1602   if (input_count == 25)
1603     exit (1);
1604   printf ("Ast # %d,", input_count);
1605   printf (" iosb = %x, %x, %x, %x",
1606           input_iosb.offset, input_iosb.status, input_iosb.termlen,
1607           input_iosb.term);
1608 #endif
1609   if (input_iosb.offset)
1610     {
1611       c = input_buffer;
1612 #ifdef ASTDEBUG
1613       printf (", char = 0%o", c);
1614 #endif
1615     }
1616 #ifdef ASTDEBUG
1617   printf ("\n");
1618   fflush (stdout);
1619   sleep (1);
1620 #endif
1621   if (! stop_input)
1622     queue_kbd_input ();
1623   if (c >= 0)
1624     {
1625       struct input_event e;
1626       e.kind = ascii_keystroke;
1627       XSET (e.code, Lisp_Int, c);
1628 #ifdef MULTI_FRAME
1629       XSET(e.frame_or_window, Lisp_Frame, selected_frame);
1630 #else
1631       e.frame_or_window = Qnil;
1632 #endif
1633       kbd_buffer_store_event (&e);
1634     }
1635   if (input_available_clear_time)
1636     EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0);
1637   errno = old_errno;
1638 }
1639
1640 /* Wait until there is something in kbd_buffer.  */
1641
1642 wait_for_kbd_input ()
1643 {
1644   extern int have_process_input, process_exited;
1645
1646   /* If already something, avoid doing system calls.  */
1647   if (detect_input_pending ())
1648     {
1649       return;
1650     }
1651   /* Clear a flag, and tell ast routine above to set it.  */
1652   SYS$CLREF (input_ef);
1653   waiting_for_ast = 1;
1654   /* Check for timing error: ast happened while we were doing that.  */
1655   if (!detect_input_pending ())
1656     {
1657       /* No timing error: wait for flag to be set.  */
1658       set_waiting_for_input (0);
1659       SYS$WFLOR (input_ef, input_eflist);
1660       clear_waiting_for_input (0);
1661       if (!detect_input_pending ())
1662         /* Check for subprocess input availability */
1663         {
1664           int dsp = have_process_input || process_exited;
1665
1666           SYS$CLREF (process_ef);
1667           if (have_process_input)
1668             process_command_input ();
1669           if (process_exited)
1670             process_exit ();
1671           if (dsp)
1672             {
1673               update_mode_lines++;
1674               prepare_menu_bars ();
1675               redisplay_preserve_echo_area ();
1676             }
1677         }
1678     }
1679   waiting_for_ast = 0;
1680 }
1681
1682 /* Get rid of any pending QIO, when we are about to suspend
1683    or when we want to throw away pending input.
1684    We wait for a positive sign that the AST routine has run
1685    and therefore there is no I/O request queued when we return.
1686    SYS$SETAST is used to avoid a timing error.  */
1687
1688 end_kbd_input ()
1689 {
1690 #ifdef ASTDEBUG
1691   printf ("At end_kbd_input.\n");
1692   fflush (stdout);
1693   sleep (1);
1694 #endif
1695   if (LIB$AST_IN_PROG ())  /* Don't wait if suspending from kbd_buffer_store_event! */
1696     {
1697       SYS$CANCEL (input_fd);
1698       return;
1699     }
1700
1701   SYS$SETAST (0);
1702   /* Clear a flag, and tell ast routine above to set it.  */
1703   SYS$CLREF (input_ef);
1704   waiting_for_ast = 1;
1705   stop_input = 1;
1706   SYS$CANCEL (input_fd);
1707   SYS$SETAST (1);
1708   SYS$WAITFR (input_ef);
1709   waiting_for_ast = 0;
1710 }
1711
1712 /* Wait for either input available or time interval expiry.  */
1713
1714 input_wait_timeout (timeval)
1715      int timeval;               /* Time to wait, in seconds */
1716 {
1717   int time [2];
1718   static int zero = 0;
1719   static int large = -10000000;
1720
1721   LIB$EMUL (&timeval, &large, &zero, time);       /* Convert to VMS format */
1722
1723   /* If already something, avoid doing system calls.  */
1724   if (detect_input_pending ())
1725     {
1726       return;
1727     }
1728   /* Clear a flag, and tell ast routine above to set it.  */
1729   SYS$CLREF (input_ef);
1730   waiting_for_ast = 1;
1731   /* Check for timing error: ast happened while we were doing that.  */
1732   if (!detect_input_pending ())
1733     {
1734       /* No timing error: wait for flag to be set.  */
1735       SYS$CANTIM (1, 0);
1736       if (SYS$SETIMR (timer_ef, time, 0, 1) & 1) /* Set timer */
1737         SYS$WFLOR (timer_ef, timer_eflist);       /* Wait for timer expiry or input */
1738     }
1739   waiting_for_ast = 0;
1740 }
1741
1742 /* The standard `sleep' routine works some other way
1743    and it stops working if you have ever quit out of it.
1744    This one continues to work.  */
1745
1746 sys_sleep (timeval)
1747      int timeval;
1748 {
1749   int time [2];
1750   static int zero = 0;
1751   static int large = -10000000;
1752
1753   LIB$EMUL (&timeval, &large, &zero, time);       /* Convert to VMS format */
1754
1755   SYS$CANTIM (1, 0);
1756   if (SYS$SETIMR (timer_ef, time, 0, 1) & 1) /* Set timer */
1757     SYS$WAITFR (timer_ef);        /* Wait for timer expiry only */
1758 }
1759
1760 init_sigio ()
1761 {
1762   request_sigio ();
1763 }
1764
1765 reset_sigio ()
1766 {
1767   unrequest_sigio ();
1768 }
1769
1770 request_sigio ()
1771 {
1772   croak ("request sigio");
1773 }
1774
1775 unrequest_sigio ()
1776 {
1777   croak ("unrequest sigio");
1778 }
1779
1780 #endif /* VMS */
1781 \f
1782 /* Note that VMS compiler won't accept defined (CANNOT_DUMP).  */
1783 #ifndef CANNOT_DUMP
1784 #define NEED_STARTS
1785 #endif
1786
1787 #ifndef SYSTEM_MALLOC
1788 #ifndef NEED_STARTS
1789 #define NEED_STARTS
1790 #endif
1791 #endif
1792
1793 #ifdef NEED_STARTS
1794 /* Some systems that cannot dump also cannot implement these.  */
1795
1796 /*
1797  *      Return the address of the start of the text segment prior to
1798  *      doing an unexec.  After unexec the return value is undefined.
1799  *      See crt0.c for further explanation and _start.
1800  *
1801  */
1802
1803 #if !defined (CANNOT_UNEXEC) && !defined (HAVE_TEXT_START)
1804 char *
1805 start_of_text ()
1806 {
1807 #ifdef TEXT_START
1808   return ((char *) TEXT_START);
1809 #else
1810 #ifdef GOULD
1811   extern csrt ();
1812   return ((char *) csrt);
1813 #else /* not GOULD */
1814   extern int _start ();
1815   return ((char *) _start);
1816 #endif /* GOULD */
1817 #endif /* TEXT_START */
1818 }
1819 #endif /* not CANNOT_UNEXEC and not HAVE_TEXT_START */
1820
1821 /*
1822  *      Return the address of the start of the data segment prior to
1823  *      doing an unexec.  After unexec the return value is undefined.
1824  *      See crt0.c for further information and definition of data_start.
1825  *
1826  *      Apparently, on BSD systems this is etext at startup.  On
1827  *      USG systems (swapping) this is highly mmu dependent and
1828  *      is also dependent on whether or not the program is running
1829  *      with shared text.  Generally there is a (possibly large)
1830  *      gap between end of text and start of data with shared text.
1831  *
1832  *      On Uniplus+ systems with shared text, data starts at a
1833  *      fixed address.  Each port (from a given oem) is generally
1834  *      different, and the specific value of the start of data can
1835  *      be obtained via the UniPlus+ specific "uvar" system call,
1836  *      however the method outlined in crt0.c seems to be more portable.
1837  *
1838  *      Probably what will have to happen when a USG unexec is available,
1839  *      at least on UniPlus, is temacs will have to be made unshared so
1840  *      that text and data are contiguous.  Then once loadup is complete,
1841  *      unexec will produce a shared executable where the data can be
1842  *      at the normal shared text boundry and the startofdata variable
1843  *      will be patched by unexec to the correct value.
1844  *
1845  */
1846
1847 char *
1848 start_of_data ()
1849 {
1850 #ifdef DATA_START
1851   return ((char *) DATA_START);
1852 #else
1853 #ifdef ORDINARY_LINK
1854   /*
1855    * This is a hack.  Since we're not linking crt0.c or pre_crt0.c,
1856    * data_start isn't defined.  We take the address of environ, which
1857    * is known to live at or near the start of the system crt0.c, and
1858    * we don't sweat the handful of bytes that might lose.
1859    */
1860   extern char **environ;
1861
1862   return((char *) &environ);
1863 #else
1864   extern int data_start;
1865   return ((char *) &data_start);
1866 #endif /* ORDINARY_LINK */
1867 #endif /* DATA_START */
1868 }
1869 #endif /* NEED_STARTS (not CANNOT_DUMP or not SYSTEM_MALLOC) */
1870
1871 #ifndef CANNOT_DUMP
1872 /* Some systems that cannot dump also cannot implement these.  */
1873
1874 /*
1875  *      Return the address of the end of the text segment prior to
1876  *      doing an unexec.  After unexec the return value is undefined.
1877  */
1878
1879 char *
1880 end_of_text ()
1881 {
1882 #ifdef TEXT_END
1883   return ((char *) TEXT_END);
1884 #else
1885   extern int etext;
1886   return ((char *) &etext);
1887 #endif
1888 }
1889
1890 /*
1891  *      Return the address of the end of the data segment prior to
1892  *      doing an unexec.  After unexec the return value is undefined.
1893  */
1894
1895 char *
1896 end_of_data ()
1897 {
1898 #ifdef DATA_END
1899   return ((char *) DATA_END);
1900 #else
1901   extern int edata;
1902   return ((char *) &edata);
1903 #endif
1904 }
1905
1906 #endif /* not CANNOT_DUMP */
1907 \f
1908 /* get_system_name returns as its value
1909  a string for the Lisp function system-name to return. */
1910
1911 #ifdef BSD4_1
1912 #include <whoami.h>
1913 #endif
1914
1915 /* Can't have this within the function since `static' is #defined to
1916    nothing for some USG systems.  */
1917 static char *get_system_name_cache;
1918 static int get_system_name_predump_p;
1919
1920 #ifndef BSD4_1
1921 #ifndef VMS
1922 #ifdef HAVE_SOCKETS
1923 #include <sys/socket.h>
1924 #include <netdb.h>
1925 #endif /* HAVE_SOCKETS */
1926 #endif /* not VMS */
1927 #endif /* not BSD4_1 */
1928
1929 char *
1930 get_system_name ()
1931 {
1932 #ifdef BSD4_1
1933   return sysname;
1934 #else
1935 #ifndef CANNOT_DUMP
1936   /* If the cached value is from before the dump, and we've dumped
1937      since then, then the cached value is no good. */
1938   if (get_system_name_predump_p && initialized && get_system_name_cache)
1939     {
1940       xfree (get_system_name_cache);
1941       get_system_name_cache = 0;
1942     }
1943 #endif
1944   if (!get_system_name_cache)
1945     {
1946       /* No cached value, so get the name from the system.  */
1947 #ifdef VMS
1948       char *sp;
1949       if ((sp = egetenv ("SYS$NODE")) == 0)
1950         sp = "vax-vms";
1951       else
1952         {
1953           char *end;
1954
1955           if ((end = index (sp, ':')) != 0)
1956             *end = '\0';
1957         }
1958       get_system_name_cache = (char *) xmalloc (strlen (sp) + 1);
1959       strcpy (get_system_name_cache, sp);
1960 #else
1961 #ifndef HAVE_GETHOSTNAME
1962       struct utsname uts;
1963       uname (&uts);
1964       get_system_name_cache = (char *) xmalloc (strlen (uts.nodename) + 1);
1965       strcpy (get_system_name_cache, uts.nodename);
1966 #else /* HAVE_GETHOSTNAME */
1967       {
1968         int hostname_size = 256;
1969         char *hostname = (char *) xmalloc (hostname_size);
1970
1971         /* Try to get the host name; if the buffer is too short, try
1972            again.  Apparently, the only indication gethostname gives of
1973            whether the buffer was large enough is the presence or absence
1974            of a '\0' in the string.  Eech.  */
1975         for (;;)
1976           {
1977             gethostname (hostname, hostname_size - 1);
1978             hostname[hostname_size - 1] = '\0';
1979
1980             /* Was the buffer large enough for the '\0'?  */
1981             if (strlen (hostname) < hostname_size - 1)
1982               break;
1983
1984             hostname_size <<= 1;
1985             hostname = (char *) xrealloc (hostname, hostname_size);
1986           }
1987         get_system_name_cache = hostname;
1988 #ifdef HAVE_SOCKETS
1989         /* Turn the hostname into the official, fully-qualified hostname.
1990            Don't do this if we're going to dump; this can confuse system
1991            libraries on some machines and make the dumped emacs core dump. */
1992 #ifndef CANNOT_DUMP
1993         if (initialized)
1994 #endif /* not CANNOT_DUMP */
1995           {
1996             struct hostent *hp = gethostbyname (hostname);
1997             if (hp)
1998               {
1999                 char *fqdn = hp->h_name;
2000                 if (!index (fqdn, '.'))
2001                   {
2002                     /* We still don't have a fully qualified domain name.
2003                        Try to find one in the list of alternate names */
2004                     char **alias = hp->h_aliases;
2005                     while (*alias && !index (*alias, '.'))
2006                       alias++;
2007                     if (*alias)
2008                       fqdn = *alias;
2009                   }
2010                 hostname = (char *) xrealloc (hostname, strlen (fqdn) + 1);
2011                 strcpy (hostname, fqdn);
2012               }
2013           }
2014 #endif /* HAVE_SOCKETS */
2015         get_system_name_cache = hostname;
2016       }
2017 #endif /* HAVE_GETHOSTNAME */
2018 #endif /* VMS */
2019 #ifndef CANNOT_DUMP
2020       get_system_name_predump_p = !initialized;
2021 #endif
2022     }
2023   return (get_system_name_cache);
2024 #endif /* BSD4_1 */
2025 }
2026 \f
2027 #ifndef VMS
2028 #ifndef HAVE_SELECT
2029
2030 #ifdef HAVE_X_WINDOWS
2031 /* Cause explanatory error message at compile time,
2032    since the select emulation is not good enough for X.  */
2033 int *x = &x_windows_lose_if_no_select_system_call;
2034 #endif
2035
2036 /* Emulate as much as select as is possible under 4.1 and needed by Gnu Emacs
2037  * Only checks read descriptors.
2038  */
2039 /* How long to wait between checking fds in select */
2040 #define SELECT_PAUSE 1
2041 int select_alarmed;
2042
2043 /* For longjmp'ing back to read_input_waiting.  */
2044
2045 jmp_buf read_alarm_throw;
2046
2047 /* Nonzero if the alarm signal should throw back to read_input_waiting.
2048    The read_socket_hook function sets this to 1 while it is waiting.  */
2049
2050 int read_alarm_should_throw;
2051
2052 SIGTYPE
2053 select_alarm ()
2054 {
2055   select_alarmed = 1;
2056 #ifdef BSD4_1
2057   sigrelse (SIGALRM);
2058 #else /* not BSD4_1 */
2059   signal (SIGALRM, SIG_IGN);
2060 #endif /* not BSD4_1 */
2061   if (read_alarm_should_throw)
2062     longjmp (read_alarm_throw, 1);
2063 }
2064
2065 /* Only rfds are checked.  */
2066 int
2067 select (nfds, rfds, wfds, efds, timeout)
2068      int nfds;
2069      int *rfds, *wfds, *efds, *timeout;
2070 {
2071   int ravail = 0, orfds = 0, old_alarm;
2072   int timeoutval = timeout ? *timeout : 100000;
2073   int *local_timeout = &timeoutval;
2074   extern int proc_buffered_char[];
2075 #ifndef subprocesses
2076   int process_tick = 0, update_tick = 0;
2077 #else
2078   extern int process_tick, update_tick;
2079 #endif
2080   SIGTYPE (*old_trap) ();
2081   unsigned char buf;
2082
2083   if (rfds)
2084     {
2085       orfds = *rfds;
2086       *rfds = 0;
2087     }
2088   if (wfds)
2089     *wfds = 0;
2090   if (efds)
2091     *efds = 0;
2092
2093   /* If we are looking only for the terminal, with no timeout,
2094      just read it and wait -- that's more efficient.  */
2095   if (orfds == 1 && *local_timeout == 100000 && process_tick == update_tick)
2096     {
2097       if (! detect_input_pending ())
2098         read_input_waiting ();
2099       *rfds = 1;
2100       return 1;
2101     }
2102
2103   /* Once a second, till the timer expires, check all the flagged read
2104    * descriptors to see if any input is available.  If there is some then
2105    * set the corresponding bit in the return copy of rfds.
2106    */
2107   while (1)
2108     {
2109       register int to_check, bit, fd;
2110
2111       if (rfds)
2112         {
2113           for (to_check = nfds, bit = 1, fd = 0; --to_check >= 0; bit <<= 1, fd++)
2114             {
2115               if (orfds & bit)
2116                 {
2117                   int avail = 0, status = 0;
2118
2119                   if (bit == 1)
2120                     avail = detect_input_pending (); /* Special keyboard handler */
2121                   else
2122                     {
2123 #ifdef FIONREAD
2124                       status = ioctl (fd, FIONREAD, &avail);
2125 #else /* no FIONREAD */
2126 #ifdef MSDOS
2127                       abort (); /* I don't think we need it.  */
2128 #else /* not MSDOS */
2129                       /* Hoping it will return -1 if nothing available
2130                          or 0 if all 0 chars requested are read.  */
2131                       if (proc_buffered_char[fd] >= 0)
2132                         avail = 1;
2133                       else
2134                         {
2135                           avail = read (fd, &buf, 1);
2136                           if (avail > 0)
2137                             proc_buffered_char[fd] = buf;
2138                         }
2139 #endif /* not MSDOS */
2140 #endif /* no FIONREAD */
2141                     }
2142                   if (status >= 0 && avail > 0)
2143                     {
2144                       (*rfds) |= bit;
2145                       ravail++;
2146                     }
2147                 }
2148             }
2149         }
2150       if (*local_timeout == 0 || ravail != 0 || process_tick != update_tick)
2151         break;
2152       old_alarm = alarm (0);
2153       old_trap = signal (SIGALRM, select_alarm);
2154       select_alarmed = 0;
2155       alarm (SELECT_PAUSE);
2156       /* Wait for a SIGALRM (or maybe a SIGTINT) */
2157       while (select_alarmed == 0 && *local_timeout != 0
2158              && process_tick == update_tick)
2159         {
2160 #ifdef MSDOS
2161           sleep_or_kbd_hit (SELECT_PAUSE, (orfds & 1) != 0);
2162           select_alarm ();
2163 #else /* not MSDOS */
2164           /* If we are interested in terminal input,
2165              wait by reading the terminal.
2166              That makes instant wakeup for terminal input at least.  */
2167           if (orfds & 1)
2168             {
2169               read_input_waiting ();
2170               if (detect_input_pending ())
2171                 select_alarmed = 1;
2172             }
2173           else
2174             pause ();
2175 #endif /* not MSDOS */
2176         }
2177       (*local_timeout) -= SELECT_PAUSE;
2178       /* Reset the old alarm if there was one */
2179       alarm (0);
2180       signal (SIGALRM, old_trap);
2181       if (old_alarm != 0)
2182         {
2183           /* Reset or forge an interrupt for the original handler. */
2184           old_alarm -= SELECT_PAUSE;
2185           if (old_alarm <= 0)
2186             kill (getpid (), SIGALRM); /* Fake an alarm with the orig' handler */
2187           else
2188             alarm (old_alarm);
2189         }
2190       if (*local_timeout == 0)  /* Stop on timer being cleared */
2191         break;
2192     }
2193   return ravail;
2194 }
2195
2196 /* Read keyboard input into the standard buffer,
2197    waiting for at least one character.  */
2198
2199 /* Make all keyboard buffers much bigger when using X windows.  */
2200 #ifdef HAVE_X_WINDOWS
2201 #define BUFFER_SIZE_FACTOR 16
2202 #else
2203 #define BUFFER_SIZE_FACTOR 1
2204 #endif
2205
2206 read_input_waiting ()
2207 {
2208   struct input_event e;
2209   int nread, i;
2210   extern int quit_char;
2211
2212   if (read_socket_hook)
2213     {
2214       struct input_event buf[256];
2215
2216       read_alarm_should_throw = 0;
2217       if (! setjmp (read_alarm_throw))
2218         nread = (*read_socket_hook) (0, buf, 256, 1, 0);
2219       else
2220         nread = -1;
2221
2222       /* Scan the chars for C-g and store them in kbd_buffer.  */
2223       for (i = 0; i < nread; i++)
2224         {
2225           kbd_buffer_store_event (&buf[i]);
2226           /* Don't look at input that follows a C-g too closely.
2227              This reduces lossage due to autorepeat on C-g.  */
2228           if (buf[i].kind == ascii_keystroke
2229               && XINT(buf[i].code) == quit_char)
2230             break;
2231         }
2232     }
2233   else
2234     {
2235       char buf[3];
2236       nread = read (fileno (stdin), buf, 1);
2237
2238       /* Scan the chars for C-g and store them in kbd_buffer.  */
2239       e.kind = ascii_keystroke;
2240       e.frame_or_window = selected_frame;
2241       e.modifiers = 0;
2242       for (i = 0; i < nread; i++)
2243         {
2244           /* Convert chars > 0177 to meta events if desired.
2245              We do this under the same conditions that read_avail_input does.  */
2246           if (read_socket_hook == 0)
2247             {
2248               /* If the user says she has a meta key, then believe her. */
2249               if (meta_key == 1 && (buf[i] & 0x80))
2250                 e.modifiers = meta_modifier;
2251               if (meta_key != 2)
2252                 buf[i] &= ~0x80;
2253             }
2254
2255           XSET (e.code, Lisp_Int, buf[i]);
2256           kbd_buffer_store_event (&e);
2257           /* Don't look at input that follows a C-g too closely.
2258              This reduces lossage due to autorepeat on C-g.  */
2259           if (buf[i] == quit_char)
2260             break;
2261         }
2262     }
2263 }
2264
2265 #endif /* not HAVE_SELECT */
2266 #endif /* not VMS */
2267 \f
2268 #ifdef BSD4_1
2269 /*
2270  * Partially emulate 4.2 open call.
2271  * open is defined as this in 4.1.
2272  *
2273  * - added by Michael Bloom @ Citicorp/TTI
2274  *
2275  */
2276
2277 int
2278 sys_open (path, oflag, mode)
2279      char *path;
2280      int oflag, mode;
2281 {
2282   if (oflag & O_CREAT)
2283     return creat (path, mode);
2284   else
2285     return open (path, oflag);
2286 }
2287
2288 init_sigio ()
2289 {
2290   if (noninteractive)
2291     return;
2292   lmode = LINTRUP | lmode;
2293   ioctl (0, TIOCLSET, &lmode);
2294 }
2295
2296 reset_sigio ()
2297 {
2298   if (noninteractive)
2299     return;
2300   lmode = ~LINTRUP & lmode;
2301   ioctl (0, TIOCLSET, &lmode);
2302 }
2303
2304 request_sigio ()
2305 {
2306   sigrelse (SIGTINT);
2307
2308   interrupts_deferred = 0;
2309 }
2310
2311 unrequest_sigio ()
2312 {
2313   sighold (SIGTINT);
2314
2315   interrupts_deferred = 1;
2316 }
2317
2318 /* still inside #ifdef BSD4_1 */
2319 #ifdef subprocesses
2320
2321 int sigheld; /* Mask of held signals */
2322
2323 sigholdx (signum)
2324      int signum;
2325 {
2326   sigheld |= sigbit (signum);
2327   sighold (signum);
2328 }
2329
2330 sigisheld (signum)
2331      int signum;
2332 {
2333   sigheld |= sigbit (signum);
2334 }
2335
2336 sigunhold (signum)
2337      int signum;
2338 {
2339   sigheld &= ~sigbit (signum);
2340   sigrelse (signum);
2341 }
2342
2343 sigfree ()    /* Free all held signals */
2344 {
2345   int i;
2346   for (i = 0; i < NSIG; i++)
2347     if (sigheld & sigbit (i))
2348       sigrelse (i);
2349   sigheld = 0;
2350 }
2351
2352 sigbit (i)
2353 {
2354   return 1 << (i - 1);
2355 }
2356 #endif /* subprocesses */
2357 #endif /* BSD4_1 */
2358 \f
2359 /* POSIX signals support - DJB */
2360 /* Anyone with POSIX signals should have ANSI C declarations */
2361
2362 #ifdef POSIX_SIGNALS
2363
2364 sigset_t old_mask, empty_mask, full_mask, temp_mask;
2365 static struct sigaction new_action, old_action;
2366
2367 init_signals ()
2368 {
2369   sigemptyset (&empty_mask);
2370   sigfillset (&full_mask);
2371 }
2372
2373 signal_handler_t
2374 sys_signal (int signal_number, signal_handler_t action)
2375 {
2376 #ifdef DGUX
2377   /* This gets us restartable system calls for efficiency.
2378      The "else" code will works as well. */
2379   return (berk_signal (signal_number, action));
2380 #else
2381   sigemptyset (&new_action.sa_mask);
2382   new_action.sa_handler = action;
2383 #ifdef SA_RESTART
2384   /* Emacs mostly works better with restartable system services. If this
2385    * flag exists, we probably want to turn it on here.
2386    */
2387   new_action.sa_flags = SA_RESTART;
2388 #else
2389   new_action.sa_flags = 0;
2390 #endif
2391   sigaction (signal_number, &new_action, &old_action);
2392   return (old_action.sa_handler);
2393 #endif /* DGUX */
2394 }
2395
2396 #ifndef __GNUC__
2397 /* If we're compiling with GCC, we don't need this function, since it
2398    can be written as a macro.  */
2399 sigset_t
2400 sys_sigmask (int sig)
2401 {
2402   sigset_t mask;
2403   sigemptyset (&mask);
2404   sigaddset (&mask, sig);
2405   return mask;
2406 }
2407 #endif
2408
2409 int
2410 sys_sigpause (sigset_t new_mask)
2411 {
2412   /* pause emulating berk sigpause... */
2413   sigsuspend (&new_mask);
2414   return (EINTR);
2415 }
2416
2417 /* I'd like to have these guys return pointers to the mask storage in here,
2418    but there'd be trouble if the code was saving multiple masks.  I'll be
2419    safe and pass the structure.  It normally won't be more than 2 bytes
2420    anyhow. - DJB */
2421
2422 sigset_t
2423 sys_sigblock (sigset_t new_mask)
2424 {
2425   sigset_t old_mask;
2426   sigprocmask (SIG_BLOCK, &new_mask, &old_mask);
2427   return (old_mask);
2428 }
2429
2430 sigset_t
2431 sys_sigunblock (sigset_t new_mask)
2432 {
2433   sigset_t old_mask;
2434   sigprocmask (SIG_UNBLOCK, &new_mask, &old_mask);
2435   return (old_mask);
2436 }
2437
2438 sigset_t
2439 sys_sigsetmask (sigset_t new_mask)
2440 {
2441   sigset_t old_mask;
2442   sigprocmask (SIG_SETMASK, &new_mask, &old_mask);
2443   return (old_mask);
2444 }
2445
2446 #endif /* POSIX_SIGNALS */
2447 \f
2448 #ifndef BSTRING
2449
2450 #ifndef bzero
2451
2452 void
2453 bzero (b, length)
2454      register char *b;
2455      register int length;
2456 {
2457 #ifdef VMS
2458   short zero = 0;
2459   long max_str = 65535;
2460
2461   while (length > max_str) {
2462     (void) LIB$MOVC5 (&zero, &zero, &zero, &max_str, b);
2463     length -= max_str;
2464     b += max_str;
2465   }
2466   max_str = length;
2467   (void) LIB$MOVC5 (&zero, &zero, &zero, &max_str, b);
2468 #else
2469   while (length-- > 0)
2470     *b++ = 0;
2471 #endif /* not VMS */
2472 }
2473
2474 #endif /* no bzero */
2475
2476 #ifndef bcopy
2477 /* Saying `void' requires a declaration, above, where bcopy is used
2478    and that declaration causes pain for systems where bcopy is a macro.  */
2479 bcopy (b1, b2, length)
2480      register char *b1;
2481      register char *b2;
2482      register int length;
2483 {
2484 #ifdef VMS
2485   long max_str = 65535;
2486
2487   while (length > max_str) {
2488     (void) LIB$MOVC3 (&max_str, b1, b2);
2489     length -= max_str;
2490     b1 += max_str;
2491     b2 += max_str;
2492   }
2493   max_str = length;
2494   (void) LIB$MOVC3 (&length, b1, b2);
2495 #else
2496   while (length-- > 0)
2497     *b2++ = *b1++;
2498 #endif /* not VMS */
2499 }
2500 #endif /* no bcopy */
2501
2502 #ifndef bcmp
2503 int
2504 bcmp (b1, b2, length)   /* This could be a macro! */
2505      register char *b1;
2506      register char *b2;
2507      register int length;
2508 {
2509 #ifdef VMS
2510   struct dsc$descriptor_s src1 = {length, DSC$K_DTYPE_T, DSC$K_CLASS_S, b1};
2511   struct dsc$descriptor_s src2 = {length, DSC$K_DTYPE_T, DSC$K_CLASS_S, b2};
2512
2513   return STR$COMPARE (&src1, &src2);
2514 #else
2515   while (length-- > 0)
2516     if (*b1++ != *b2++)
2517       return 1;
2518
2519   return 0;
2520 #endif /* not VMS */
2521 }
2522 #endif /* no bcmp */
2523
2524 #endif /* not BSTRING */
2525 \f
2526 #ifndef HAVE_RANDOM
2527 #ifdef USG
2528 /*
2529  *      The BSD random returns numbers in the range of
2530  *      0 to 2e31 - 1.  The USG rand returns numbers in the
2531  *      range of 0 to 2e15 - 1.  This is probably not significant
2532  *      in this usage.
2533  */
2534
2535 long
2536 random ()
2537 {
2538   /* Arrange to return a range centered on zero.  */
2539   return (rand () << 15) + rand () - (1 << 29);
2540 }
2541
2542 srandom (arg)
2543      int arg;
2544 {
2545   srand (arg);
2546 }
2547
2548 #endif /* USG */
2549
2550 #ifdef BSD4_1
2551 long random ()
2552 {
2553   /* Arrange to return a range centered on zero.  */
2554   return (rand () << 15) + rand () - (1 << 29);
2555 }
2556
2557 srandom (arg)
2558      int arg;
2559 {
2560   srand (arg);
2561 }
2562 #endif /* BSD4_1 */
2563 #endif
2564 \f
2565 #ifdef WRONG_NAME_INSQUE
2566
2567 insque (q,p)
2568      caddr_t q,p;
2569 {
2570   _insque (q,p);
2571 }
2572
2573 #endif
2574 \f
2575 #ifdef VMS
2576
2577 #ifdef getenv
2578 /* If any place else asks for the TERM variable,
2579    allow it to be overridden with the EMACS_TERM variable
2580    before attempting to translate the logical name TERM.  As a last
2581    resort, ask for VAX C's special idea of the TERM variable.  */
2582 #undef getenv
2583 char *
2584 sys_getenv (name)
2585      char *name;
2586 {
2587   register char *val;
2588   static char buf[256];
2589   static struct dsc$descriptor_s equiv
2590     = {sizeof (buf), DSC$K_DTYPE_T, DSC$K_CLASS_S, buf};
2591   static struct dsc$descriptor_s d_name
2592     = {0, DSC$K_DTYPE_T, DSC$K_CLASS_S, 0};
2593   short eqlen;
2594
2595   if (!strcmp (name, "TERM"))
2596     {
2597       val = (char *) getenv ("EMACS_TERM");
2598       if (val)
2599         return val;
2600     }
2601
2602   d_name.dsc$w_length = strlen (name);
2603   d_name.dsc$a_pointer = name;
2604   if (LIB$SYS_TRNLOG (&d_name, &eqlen, &equiv) == 1)
2605     {
2606       char *str = (char *) xmalloc (eqlen + 1);
2607       bcopy (buf, str, eqlen);
2608       str[eqlen] = '\0';
2609       /* This is a storage leak, but a pain to fix.  With luck,
2610          no one will ever notice.  */
2611       return str;
2612     }
2613   return (char *) getenv (name);
2614 }
2615 #endif /* getenv */
2616
2617 #ifdef abort
2618 /* Since VMS doesn't believe in core dumps, the only way to debug this beast is
2619    to force a call on the debugger from within the image. */
2620 #undef abort
2621 sys_abort ()
2622 {
2623   reset_sys_modes ();
2624   LIB$SIGNAL (SS$_DEBUG);
2625 }
2626 #endif /* abort */
2627 #endif /* VMS */
2628 \f
2629 #ifdef VMS
2630 #ifdef LINK_CRTL_SHARE
2631 #ifdef SHAREABLE_LIB_BUG
2632 /* Variables declared noshare and initialized in sharable libraries
2633    cannot be shared.  The VMS linker incorrectly forces you to use a private
2634    version which is uninitialized... If not for this "feature", we
2635    could use the C library definition of sys_nerr and sys_errlist. */
2636 int sys_nerr = 35;
2637 char *sys_errlist[] =
2638   {
2639     "error 0",
2640     "not owner",
2641     "no such file or directory",
2642     "no such process",
2643     "interrupted system call",
2644     "i/o error",
2645     "no such device or address",
2646     "argument list too long",
2647     "exec format error",
2648     "bad file number",
2649     "no child process",
2650     "no more processes",
2651     "not enough memory",
2652     "permission denied",
2653     "bad address",
2654     "block device required",
2655     "mount devices busy",
2656     "file exists",
2657     "cross-device link",
2658     "no such device",
2659     "not a directory",
2660     "is a directory",
2661     "invalid argument",
2662     "file table overflow",
2663     "too many open files",
2664     "not a typewriter",
2665     "text file busy",
2666     "file too big",
2667     "no space left on device",
2668     "illegal seek",
2669     "read-only file system",
2670     "too many links",
2671     "broken pipe",
2672     "math argument",
2673     "result too large",
2674     "I/O stream empty",
2675     "vax/vms specific error code nontranslatable error"
2676   };
2677 #endif /* SHAREABLE_LIB_BUG */
2678 #endif /* LINK_CRTL_SHARE */
2679 #endif /* VMS */
2680
2681 #ifndef HAVE_STRERROR
2682 char *
2683 strerror (errnum)
2684      int errnum;
2685 {
2686   extern char *sys_errlist[];
2687   extern int sys_nerr;
2688
2689   if (errnum >= 0 && errnum < sys_nerr)
2690     return sys_errlist[errnum];
2691   return (char *) "Unknown error";
2692 }
2693
2694 #endif /* ! HAVE_STRERROR */
2695 \f
2696 #ifdef INTERRUPTIBLE_OPEN
2697
2698 int
2699 /* VARARGS 2 */
2700 sys_open (path, oflag, mode)
2701      char *path;
2702      int oflag, mode;
2703 {
2704   register int rtnval;
2705
2706   while ((rtnval = open (path, oflag, mode)) == -1
2707          && (errno == EINTR));
2708   return (rtnval);
2709 }
2710
2711 #endif /* INTERRUPTIBLE_OPEN */
2712
2713 #ifdef INTERRUPTIBLE_CLOSE
2714
2715 sys_close (fd)
2716      int fd;
2717 {
2718   register int rtnval;
2719
2720   while ((rtnval = close (fd)) == -1
2721          && (errno == EINTR));
2722   return rtnval;
2723 }
2724
2725 #endif /* INTERRUPTIBLE_CLOSE */
2726
2727 #ifdef INTERRUPTIBLE_IO
2728
2729 int
2730 sys_read (fildes, buf, nbyte)
2731      int fildes;
2732      char *buf;
2733      unsigned int nbyte;
2734 {
2735   register int rtnval;
2736
2737   while ((rtnval = read (fildes, buf, nbyte)) == -1
2738          && (errno == EINTR));
2739   return (rtnval);
2740 }
2741
2742 int
2743 sys_write (fildes, buf, nbyte)
2744      int fildes;
2745      char *buf;
2746      unsigned int nbyte;
2747 {
2748   register int rtnval, bytes_written;
2749
2750   bytes_written = 0;
2751
2752   while (nbyte > 0)
2753     {
2754       rtnval = write (fildes, buf, nbyte);
2755
2756       if (rtnval == -1)
2757         {
2758           if (errno == EINTR)
2759             continue;
2760           else
2761             return (bytes_written ? bytes_written : -1);
2762         }
2763
2764       buf += rtnval;
2765       nbyte -= rtnval;
2766       bytes_written += rtnval;
2767     }
2768   return (bytes_written);
2769 }
2770
2771 #endif /* INTERRUPTIBLE_IO */
2772 \f
2773 #ifndef HAVE_VFORK
2774
2775 /*
2776  *      Substitute fork for vfork on USG flavors.
2777  */
2778
2779 vfork ()
2780 {
2781   return (fork ());
2782 }
2783
2784 #endif /* not HAVE_VFORK */
2785 \f
2786 #ifdef USG
2787 /*
2788  *      All of the following are for USG.
2789  *
2790  *      On USG systems the system calls are INTERRUPTIBLE by signals
2791  *      that the user program has elected to catch.  Thus the system call
2792  *      must be retried in these cases.  To handle this without massive
2793  *      changes in the source code, we remap the standard system call names
2794  *      to names for our own functions in sysdep.c that do the system call
2795  *      with retries.  Actually, for portability reasons, it is good
2796  *      programming practice, as this example shows, to limit all actual
2797  *      system calls to a single occurrence in the source.  Sure, this
2798  *      adds an extra level of function call overhead but it is almost
2799  *      always negligible.   Fred Fish, Unisoft Systems Inc.
2800  */
2801
2802 #ifndef HAVE_SYS_SIGLIST
2803 char *sys_siglist[NSIG + 1] =
2804 {
2805 #ifdef AIX
2806 /* AIX has changed the signals a bit */
2807   "bogus signal",                       /* 0 */
2808   "hangup",                             /* 1  SIGHUP */
2809   "interrupt",                          /* 2  SIGINT */
2810   "quit",                               /* 3  SIGQUIT */
2811   "illegal instruction",                /* 4  SIGILL */
2812   "trace trap",                         /* 5  SIGTRAP */
2813   "IOT instruction",                    /* 6  SIGIOT */
2814   "crash likely",                       /* 7  SIGDANGER */
2815   "floating point exception",           /* 8  SIGFPE */
2816   "kill",                               /* 9  SIGKILL */
2817   "bus error",                          /* 10 SIGBUS */
2818   "segmentation violation",             /* 11 SIGSEGV */
2819   "bad argument to system call",        /* 12 SIGSYS */
2820   "write on a pipe with no one to read it", /* 13 SIGPIPE */
2821   "alarm clock",                        /* 14 SIGALRM */
2822   "software termination signum",        /* 15 SIGTERM */
2823   "user defined signal 1",              /* 16 SIGUSR1 */
2824   "user defined signal 2",              /* 17 SIGUSR2 */
2825   "death of a child",                   /* 18 SIGCLD */
2826   "power-fail restart",                 /* 19 SIGPWR */
2827   "bogus signal",                       /* 20 */
2828   "bogus signal",                       /* 21 */
2829   "bogus signal",                       /* 22 */
2830   "bogus signal",                       /* 23 */
2831   "bogus signal",                       /* 24 */
2832   "LAN I/O interrupt",                  /* 25 SIGAIO */
2833   "PTY I/O interrupt",                  /* 26 SIGPTY */
2834   "I/O intervention required",          /* 27 SIGIOINT */
2835   "HFT grant",                          /* 28 SIGGRANT */
2836   "HFT retract",                        /* 29 SIGRETRACT */
2837   "HFT sound done",                     /* 30 SIGSOUND */
2838   "HFT input ready",                    /* 31 SIGMSG */
2839 #else /* not AIX */
2840   "bogus signal",                       /* 0 */
2841   "hangup",                             /* 1  SIGHUP */
2842   "interrupt",                          /* 2  SIGINT */
2843   "quit",                               /* 3  SIGQUIT */
2844   "illegal instruction",                /* 4  SIGILL */
2845   "trace trap",                         /* 5  SIGTRAP */
2846   "IOT instruction",                    /* 6  SIGIOT */
2847   "EMT instruction",                    /* 7  SIGEMT */
2848   "floating point exception",           /* 8  SIGFPE */
2849   "kill",                               /* 9  SIGKILL */
2850   "bus error",                          /* 10 SIGBUS */
2851   "segmentation violation",             /* 11 SIGSEGV */
2852   "bad argument to system call",        /* 12 SIGSYS */
2853   "write on a pipe with no one to read it", /* 13 SIGPIPE */
2854   "alarm clock",                        /* 14 SIGALRM */
2855   "software termination signum",        /* 15 SIGTERM */
2856   "user defined signal 1",              /* 16 SIGUSR1 */
2857   "user defined signal 2",              /* 17 SIGUSR2 */
2858   "death of a child",                   /* 18 SIGCLD */
2859   "power-fail restart",                 /* 19 SIGPWR */
2860 #ifdef sun
2861   "window size change",                     /* 20 SIGWINCH */
2862   "urgent socket condition",                /* 21 SIGURG */
2863   "pollable event occured",                 /* 22 SIGPOLL */
2864   "stop (cannot be caught or ignored)", /*  23 SIGSTOP */
2865   "user stop requested from tty",           /* 24 SIGTSTP */
2866   "stopped process has been continued", /* 25 SIGCONT */
2867   "background tty read attempted",          /* 26 SIGTTIN */
2868   "background tty write attempted",    /* 27 SIGTTOU */
2869   "virtual timer expired",                  /* 28 SIGVTALRM */
2870   "profiling timer expired",                /* 29 SIGPROF */
2871   "exceeded cpu limit",                     /* 30 SIGXCPU */
2872   "exceeded file size limit",               /* 31 SIGXFSZ */
2873   "process's lwps are blocked",     /*  32 SIGWAITING */
2874   "special signal used by thread library", /* 33 SIGLWP */
2875   "Special Signal Used By CPR",     /* 34 SIGFREEZE */
2876   "Special Signal Used By CPR",     /* 35 SIGTHAW */
2877 #endif /* sun */
2878 #endif /* not AIX */
2879   0
2880   };
2881 #endif /* HAVE_SYS_SIGLIST */
2882
2883 /*
2884  *      Warning, this function may not duplicate 4.2 action properly
2885  *      under error conditions.
2886  */
2887
2888 #ifndef MAXPATHLEN
2889 /* In 4.1, param.h fails to define this.  */
2890 #define MAXPATHLEN 1024
2891 #endif
2892
2893 #ifndef HAVE_GETWD
2894
2895 char *
2896 getwd (pathname)
2897      char *pathname;
2898 {
2899   char *npath, *spath;
2900   extern char *getcwd ();
2901
2902   BLOCK_INPUT;                  /* getcwd uses malloc */
2903   spath = npath = getcwd ((char *) 0, MAXPATHLEN);
2904   if (spath == 0)
2905     return spath;
2906   /* On Altos 3068, getcwd can return @hostname/dir, so discard
2907      up to first slash.  Should be harmless on other systems.  */
2908   while (*npath && *npath != '/')
2909     npath++;
2910   strcpy (pathname, npath);
2911   free (spath);                 /* getcwd uses malloc */
2912   UNBLOCK_INPUT;
2913   return pathname;
2914 }
2915
2916 #endif /* HAVE_GETWD */
2917
2918 /*
2919  *      Emulate rename using unlink/link.  Note that this is
2920  *      only partially correct.  Also, doesn't enforce restriction
2921  *      that files be of same type (regular->regular, dir->dir, etc).
2922  */
2923
2924 #ifndef HAVE_RENAME
2925
2926 rename (from, to)
2927      const char *from;
2928      const char *to;
2929 {
2930   if (access (from, 0) == 0)
2931     {
2932       unlink (to);
2933       if (link (from, to) == 0)
2934         if (unlink (from) == 0)
2935           return (0);
2936     }
2937   return (-1);
2938 }
2939
2940 #endif
2941
2942 #ifdef MISSING_UTIMES
2943
2944 /* HPUX (among others) sets HAVE_TIMEVAL but does not implement utimes.  */
2945
2946 utimes ()
2947 {
2948 }
2949 #endif
2950
2951 #ifdef IRIS_UTIME
2952
2953 /* The IRIS (3.5) has timevals, but uses sys V utime, and doesn't have the
2954    utimbuf structure defined anywhere but in the man page. */
2955
2956 struct utimbuf
2957  {
2958    long actime;
2959    long modtime;
2960  };
2961
2962 utimes (name, tvp)
2963      char *name;
2964      struct timeval tvp[];
2965 {
2966   struct utimbuf utb;
2967   utb.actime  = tvp[0].tv_sec;
2968   utb.modtime = tvp[1].tv_sec;
2969   utime (name, &utb);
2970 }
2971 #endif /* IRIS_UTIME */
2972
2973
2974 #ifdef HPUX
2975 #ifndef HAVE_PERROR
2976
2977 /* HPUX curses library references perror, but as far as we know
2978    it won't be called.  Anyway this definition will do for now.  */
2979
2980 perror ()
2981 {
2982 }
2983
2984 #endif /* not HAVE_PERROR */
2985 #endif /* HPUX */
2986
2987 #ifndef HAVE_DUP2
2988
2989 /*
2990  *      Emulate BSD dup2.  First close newd if it already exists.
2991  *      Then, attempt to dup oldd.  If not successful, call dup2 recursively
2992  *      until we are, then close the unsuccessful ones.
2993  */
2994
2995 dup2 (oldd, newd)
2996      int oldd;
2997      int newd;
2998 {
2999   register int fd, ret;
3000
3001   sys_close (newd);
3002
3003 #ifdef F_DUPFD
3004   fd = fcntl (oldd, F_DUPFD, newd);
3005   if (fd != newd)
3006     error ("can't dup2 (%i,%i) : %s", oldd, newd, strerror (errno));
3007 #else
3008   fd = dup (old);
3009   if (fd == -1)
3010     return -1;
3011   if (fd == new)
3012     return new;
3013   ret = dup2 (old,new);
3014   sys_close (fd);
3015   return ret;
3016 #endif
3017 }
3018
3019 #endif /* not HAVE_DUP2 */
3020
3021 /*
3022  *      Gettimeofday.  Simulate as much as possible.  Only accurate
3023  *      to nearest second.  Emacs doesn't use tzp so ignore it for now.
3024  *      Only needed when subprocesses are defined.
3025  */
3026
3027 #ifdef subprocesses
3028 #ifndef VMS
3029 #ifndef HAVE_GETTIMEOFDAY
3030 #ifdef HAVE_TIMEVAL
3031
3032 /* ARGSUSED */
3033 gettimeofday (tp, tzp)
3034      struct timeval *tp;
3035      struct timezone *tzp;
3036 {
3037   extern long time ();
3038
3039   tp->tv_sec = time ((long *)0);
3040   tp->tv_usec = 0;
3041   if (tzp != 0)
3042     tzp->tz_minuteswest = -1;
3043 }
3044
3045 #endif
3046 #endif
3047 #endif
3048 #endif /* subprocess && !HAVE_GETTIMEOFDAY && HAVE_TIMEVAL && !VMS */
3049
3050 /*
3051  *      This function will go away as soon as all the stubs fixed. (fnf)
3052  */
3053
3054 croak (badfunc)
3055      char *badfunc;
3056 {
3057   printf ("%s not yet implemented\r\n", badfunc);
3058   reset_sys_modes ();
3059   exit (1);
3060 }
3061
3062 #endif /* USG */
3063 \f
3064 #ifdef DGUX
3065
3066 char *sys_siglist[NSIG + 1] =
3067 {
3068   "null signal",                         /*  0 SIGNULL   */
3069   "hangup",                              /*  1 SIGHUP    */
3070   "interrupt",                           /*  2 SIGINT    */
3071   "quit",                                /*  3 SIGQUIT   */
3072   "illegal instruction",                 /*  4 SIGILL    */
3073   "trace trap",                          /*  5 SIGTRAP   */
3074   "abort termination",                   /*  6 SIGABRT   */
3075   "SIGEMT",                              /*  7 SIGEMT    */
3076   "floating point exception",            /*  8 SIGFPE    */
3077   "kill",                                /*  9 SIGKILL   */
3078   "bus error",                           /* 10 SIGBUS    */
3079   "segmentation violation",              /* 11 SIGSEGV   */
3080   "bad argument to system call",         /* 12 SIGSYS    */
3081   "write on a pipe with no reader",      /* 13 SIGPIPE   */
3082   "alarm clock",                         /* 14 SIGALRM   */
3083   "software termination signal",         /* 15 SIGTERM   */
3084   "user defined signal 1",               /* 16 SIGUSR1   */
3085   "user defined signal 2",               /* 17 SIGUSR2   */
3086   "child stopped or terminated",         /* 18 SIGCLD    */
3087   "power-fail restart",                  /* 19 SIGPWR    */
3088   "window size changed",                 /* 20 SIGWINCH  */
3089   "undefined",                           /* 21           */
3090   "pollable event occurred",             /* 22 SIGPOLL   */
3091   "sendable stop signal not from tty",   /* 23 SIGSTOP   */
3092   "stop signal from tty",                /* 24 SIGSTP    */
3093   "continue a stopped process",          /* 25 SIGCONT   */
3094   "attempted background tty read",       /* 26 SIGTTIN   */
3095   "attempted background tty write",      /* 27 SIGTTOU   */
3096   "undefined",                           /* 28           */
3097   "undefined",                           /* 29           */
3098   "undefined",                           /* 30           */
3099   "undefined",                           /* 31           */
3100   "undefined",                           /* 32           */
3101   "socket (TCP/IP) urgent data arrival", /* 33 SIGURG    */
3102   "I/O is possible",                     /* 34 SIGIO     */
3103   "exceeded cpu time limit",             /* 35 SIGXCPU   */
3104   "exceeded file size limit",            /* 36 SIGXFSZ   */
3105   "virtual time alarm",                  /* 37 SIGVTALRM */
3106   "profiling time alarm",                /* 38 SIGPROF   */
3107   "undefined",                           /* 39           */
3108   "file record locks revoked",           /* 40 SIGLOST   */
3109   "undefined",                           /* 41           */
3110   "undefined",                           /* 42           */
3111   "undefined",                           /* 43           */
3112   "undefined",                           /* 44           */
3113   "undefined",                           /* 45           */
3114   "undefined",                           /* 46           */
3115   "undefined",                           /* 47           */
3116   "undefined",                           /* 48           */
3117   "undefined",                           /* 49           */
3118   "undefined",                           /* 50           */
3119   "undefined",                           /* 51           */
3120   "undefined",                           /* 52           */
3121   "undefined",                           /* 53           */
3122   "undefined",                           /* 54           */
3123   "undefined",                           /* 55           */
3124   "undefined",                           /* 56           */
3125   "undefined",                           /* 57           */
3126   "undefined",                           /* 58           */
3127   "undefined",                           /* 59           */
3128   "undefined",                           /* 60           */
3129   "undefined",                           /* 61           */
3130   "undefined",                           /* 62           */
3131   "undefined",                           /* 63           */
3132   "notification message in mess. queue", /* 64 SIGDGNOTIFY */
3133   0
3134 };
3135
3136 #endif /* DGUX */
3137 \f
3138 /* Directory routines for systems that don't have them. */
3139
3140 #ifdef SYSV_SYSTEM_DIR
3141
3142 #include <dirent.h>
3143
3144 #if defined(BROKEN_CLOSEDIR) || !defined(HAVE_CLOSEDIR)
3145
3146 int
3147 closedir (dirp)
3148      register DIR *dirp;              /* stream from opendir */
3149 {
3150   int rtnval;
3151
3152   rtnval = sys_close (dirp->dd_fd);
3153
3154   /* Some systems (like Solaris) allocate the buffer and the DIR all
3155      in one block.  Why in the world are we freeing this ourselves
3156      anyway?  */
3157 #if ! (defined (sun) && defined (USG5_4))
3158   xfree ((char *) dirp->dd_buf); /* directory block defined in <dirent.h> */
3159 #endif
3160   xfree ((char *) dirp);
3161
3162   return rtnval;
3163 }
3164 #endif /* BROKEN_CLOSEDIR or not HAVE_CLOSEDIR */
3165 #endif /* SYSV_SYSTEM_DIR */
3166
3167 #ifdef NONSYSTEM_DIR_LIBRARY
3168
3169 DIR *
3170 opendir (filename)
3171      char *filename;    /* name of directory */
3172 {
3173   register DIR *dirp;           /* -> malloc'ed storage */
3174   register int fd;              /* file descriptor for read */
3175   struct stat sbuf;             /* result of fstat */
3176
3177   fd = sys_open (filename, 0);
3178   if (fd < 0)
3179     return 0;
3180
3181   BLOCK_INPUT;
3182   if (fstat (fd, &sbuf) < 0
3183       || (sbuf.st_mode & S_IFMT) != S_IFDIR
3184       || (dirp = (DIR *) malloc (sizeof (DIR))) == 0)
3185     {
3186       sys_close (fd);
3187       UNBLOCK_INPUT;
3188       return 0;         /* bad luck today */
3189     }
3190   UNBLOCK_INPUT;
3191
3192   dirp->dd_fd = fd;
3193   dirp->dd_loc = dirp->dd_size = 0;     /* refill needed */
3194
3195   return dirp;
3196 }
3197
3198 void
3199 closedir (dirp)
3200      register DIR *dirp;                /* stream from opendir */
3201 {
3202   sys_close (dirp->dd_fd);
3203   xfree ((char *) dirp);
3204 }
3205
3206
3207 #ifndef VMS
3208 #define DIRSIZ  14
3209 struct olddir
3210   {
3211     ino_t od_ino;               /* inode */
3212     char od_name[DIRSIZ];       /* filename */
3213   };
3214 #endif /* not VMS */
3215
3216 struct direct dir_static;       /* simulated directory contents */
3217
3218 /* ARGUSED */
3219 struct direct *
3220 readdir (dirp)
3221      register DIR *dirp;        /* stream from opendir */
3222 {
3223 #ifndef VMS
3224   register struct olddir *dp;   /* -> directory data */
3225 #else /* VMS */
3226   register struct dir$_name *dp; /* -> directory data */
3227   register struct dir$_version *dv; /* -> version data */
3228 #endif /* VMS */
3229
3230   for (; ;)
3231     {
3232       if (dirp->dd_loc >= dirp->dd_size)
3233         dirp->dd_loc = dirp->dd_size = 0;
3234
3235       if (dirp->dd_size == 0    /* refill buffer */
3236           && (dirp->dd_size = sys_read (dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ)) <= 0)
3237         return 0;
3238
3239 #ifndef VMS
3240       dp = (struct olddir *) &dirp->dd_buf[dirp->dd_loc];
3241       dirp->dd_loc += sizeof (struct olddir);
3242
3243       if (dp->od_ino != 0)      /* not deleted entry */
3244         {
3245           dir_static.d_ino = dp->od_ino;
3246           strncpy (dir_static.d_name, dp->od_name, DIRSIZ);
3247           dir_static.d_name[DIRSIZ] = '\0';
3248           dir_static.d_namlen = strlen (dir_static.d_name);
3249           dir_static.d_reclen = sizeof (struct direct)
3250             - MAXNAMLEN + 3
3251               + dir_static.d_namlen - dir_static.d_namlen % 4;
3252           return &dir_static;   /* -> simulated structure */
3253         }
3254 #else /* VMS */
3255       dp = (struct dir$_name *) dirp->dd_buf;
3256       if (dirp->dd_loc == 0)
3257         dirp->dd_loc = (dp->dir$b_namecount&1) ? dp->dir$b_namecount + 1
3258           : dp->dir$b_namecount;
3259       dv = (struct dir$_version *)&dp->dir$t_name[dirp->dd_loc];
3260       dir_static.d_ino = dv->dir$w_fid_num;
3261       dir_static.d_namlen = dp->dir$b_namecount;
3262       dir_static.d_reclen = sizeof (struct direct)
3263         - MAXNAMLEN + 3
3264           + dir_static.d_namlen - dir_static.d_namlen % 4;
3265       strncpy (dir_static.d_name, dp->dir$t_name, dp->dir$b_namecount);
3266       dir_static.d_name[dir_static.d_namlen] = '\0';
3267       dirp->dd_loc = dirp->dd_size; /* only one record at a time */
3268       return &dir_static;
3269 #endif /* VMS */
3270     }
3271 }
3272
3273 #ifdef VMS
3274 /* readdirver is just like readdir except it returns all versions of a file
3275    as separate entries.  */
3276
3277 /* ARGUSED */
3278 struct direct *
3279 readdirver (dirp)
3280      register DIR *dirp;        /* stream from opendir */
3281 {
3282   register struct dir$_name *dp; /* -> directory data */
3283   register struct dir$_version *dv; /* -> version data */
3284
3285   if (dirp->dd_loc >= dirp->dd_size - sizeof (struct dir$_name))
3286     dirp->dd_loc = dirp->dd_size = 0;
3287
3288   if (dirp->dd_size == 0        /* refill buffer */
3289       && (dirp->dd_size = sys_read (dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ)) <= 0)
3290     return 0;
3291
3292   dp = (struct dir$_name *) dirp->dd_buf;
3293   if (dirp->dd_loc == 0)
3294     dirp->dd_loc = (dp->dir$b_namecount & 1) ? dp->dir$b_namecount + 1
3295                    : dp->dir$b_namecount;
3296   dv = (struct dir$_version *) &dp->dir$t_name[dirp->dd_loc];
3297   strncpy (dir_static.d_name, dp->dir$t_name, dp->dir$b_namecount);
3298   sprintf (&dir_static.d_name[dp->dir$b_namecount], ";%d", dv->dir$w_version);
3299   dir_static.d_namlen = strlen (dir_static.d_name);
3300   dir_static.d_ino = dv->dir$w_fid_num;
3301   dir_static.d_reclen = sizeof (struct direct) - MAXNAMLEN + 3
3302                         + dir_static.d_namlen - dir_static.d_namlen % 4;
3303   dirp->dd_loc = ((char *) (++dv) - dp->dir$t_name);
3304   return &dir_static;
3305 }
3306
3307 #endif /* VMS */
3308
3309 #endif /* NONSYSTEM_DIR_LIBRARY */
3310
3311 \f
3312 /* mkdir and rmdir functions, for systems which don't have them.  */
3313
3314 #ifndef HAVE_MKDIR
3315 /*
3316  * Written by Robert Rother, Mariah Corporation, August 1985.
3317  *
3318  * If you want it, it's yours.  All I ask in return is that if you
3319  * figure out how to do this in a Bourne Shell script you send me
3320  * a copy.
3321  *                                      sdcsvax!rmr or rmr@uscd
3322  *
3323  * Severely hacked over by John Gilmore to make a 4.2BSD compatible
3324  * subroutine.  11Mar86; hoptoad!gnu
3325  *
3326  * Modified by rmtodd@uokmax 6-28-87 -- when making an already existing dir,
3327  * subroutine didn't return EEXIST.  It does now.
3328  */
3329
3330 /*
3331  * Make a directory.
3332  */
3333 #ifdef MKDIR_PROTOTYPE
3334 MKDIR_PROTOTYPE
3335 #else
3336 int
3337 mkdir (dpath, dmode)
3338      char *dpath;
3339      int dmode;
3340 #endif
3341 {
3342   int cpid, status, fd;
3343   struct stat statbuf;
3344
3345   if (stat (dpath, &statbuf) == 0)
3346     {
3347       errno = EEXIST;           /* Stat worked, so it already exists */
3348       return -1;
3349     }
3350
3351   /* If stat fails for a reason other than non-existence, return error */
3352   if (errno != ENOENT)
3353     return -1;
3354
3355   synch_process_alive = 1;
3356   switch (cpid = fork ())
3357     {
3358
3359     case -1:                    /* Error in fork */
3360       return (-1);              /* Errno is set already */
3361
3362     case 0:                     /* Child process */
3363       /*
3364                  * Cheap hack to set mode of new directory.  Since this
3365                  * child process is going away anyway, we zap its umask.
3366                  * FIXME, this won't suffice to set SUID, SGID, etc. on this
3367                  * directory.  Does anybody care?
3368                  */
3369       status = umask (0);       /* Get current umask */
3370       status = umask (status | (0777 & ~dmode));        /* Set for mkdir */
3371       fd = sys_open("/dev/null", 2);
3372       if (fd >= 0)
3373         {
3374           dup2 (fd, 0);
3375           dup2 (fd, 1);
3376           dup2 (fd, 2);
3377         }
3378       execl ("/bin/mkdir", "mkdir", dpath, (char *) 0);
3379       _exit (-1);               /* Can't exec /bin/mkdir */
3380
3381     default:                    /* Parent process */
3382       wait_for_termination (cpid);
3383     }
3384
3385   if (synch_process_death != 0 || synch_process_retcode != 0)
3386     {
3387       errno = EIO;              /* We don't know why, but */
3388       return -1;                /* /bin/mkdir failed */
3389     }
3390
3391   return 0;
3392 }
3393 #endif /* not HAVE_MKDIR */
3394
3395 #ifndef HAVE_RMDIR
3396 int
3397 rmdir (dpath)
3398      char *dpath;
3399 {
3400   int cpid, status, fd;
3401   struct stat statbuf;
3402
3403   if (stat (dpath, &statbuf) != 0)
3404     {
3405       /* Stat just set errno.  We don't have to */
3406       return -1;
3407     }
3408
3409   synch_process_alive = 1;
3410   switch (cpid = fork ())
3411     {
3412
3413     case -1:                    /* Error in fork */
3414       return (-1);              /* Errno is set already */
3415
3416     case 0:                     /* Child process */
3417       fd = sys_open("/dev/null", 2);
3418       if (fd >= 0)
3419         {
3420           dup2 (fd, 0);
3421           dup2 (fd, 1);
3422           dup2 (fd, 2);
3423         }
3424       wait_for_termination (cpid);
3425   if (synch_process_death != 0 || synch_process_retcode != 0)
3426       return -1;                /* /bin/rmdir failed */
3427     default:                    /* Parent process */
3428       while (cpid != wait (&status));   /* Wait for kid to finish */
3429     }
3430
3431   if (WIFSIGNALED (status) || WEXITSTATUS (status) != 0)
3432     {
3433       errno = EIO;              /* We don't know why, but */
3434       return -1;                /* /bin/mkdir failed */
3435     }
3436
3437   return 0;
3438 }
3439 #endif /* !HAVE_RMDIR */
3440
3441
3442 \f
3443 /* Functions for VMS */
3444 #ifdef VMS
3445 #include "vms-pwd.h"
3446 #include <acldef.h>
3447 #include <chpdef.h>
3448 #include <jpidef.h>
3449
3450 /* Return as a string the VMS error string pertaining to STATUS.
3451    Reuses the same static buffer each time it is called.  */
3452
3453 char *
3454 vmserrstr (status)
3455      int status;                /* VMS status code */
3456 {
3457   int bufadr[2];
3458   short len;
3459   static char buf[257];
3460
3461   bufadr[0] = sizeof buf - 1;
3462   bufadr[1] = (int) buf;
3463   if (! (SYS$GETMSG (status, &len, bufadr, 0x1, 0) & 1))
3464     return "untranslatable VMS error status";
3465   buf[len] = '\0';
3466   return buf;
3467 }
3468
3469 #ifdef access
3470 #undef access
3471
3472 /* The following is necessary because 'access' emulation by VMS C (2.0) does
3473  * not work correctly.  (It also doesn't work well in version 2.3.)
3474  */
3475
3476 #ifdef VMS4_4
3477
3478 #define DESCRIPTOR(name,string) struct dsc$descriptor_s name = \
3479         { strlen (string), DSC$K_DTYPE_T, DSC$K_CLASS_S, string }
3480
3481 typedef union {
3482     struct {
3483         unsigned short s_buflen;
3484         unsigned short s_code;
3485         char *s_bufadr;
3486         unsigned short *s_retlenadr;
3487     } s;
3488     int end;
3489 } item;
3490 #define buflen s.s_buflen
3491 #define code s.s_code
3492 #define bufadr s.s_bufadr
3493 #define retlenadr s.s_retlenadr
3494
3495 #define R_OK 4  /* test for read permission */
3496 #define W_OK 2  /* test for write permission */
3497 #define X_OK 1  /* test for execute (search) permission */
3498 #define F_OK 0  /* test for presence of file */
3499
3500 int
3501 sys_access (path, mode)
3502      char *path;
3503      int mode;
3504 {
3505   static char *user = NULL;
3506   char dir_fn[512];
3507
3508   /* translate possible directory spec into .DIR file name, so brain-dead
3509    * access can treat the directory like a file.  */
3510   if (directory_file_name (path, dir_fn))
3511     path = dir_fn;
3512
3513   if (mode == F_OK)
3514     return access (path, mode);
3515   if (user == NULL && (user = (char *) getenv ("USER")) == NULL)
3516     return -1;
3517   {
3518     int stat;
3519     int flags;
3520     int acces;
3521     unsigned short int dummy;
3522     item itemlst[3];
3523     static int constant = ACL$C_FILE;
3524     DESCRIPTOR (path_desc, path);
3525     DESCRIPTOR (user_desc, user);
3526
3527     flags = 0;
3528     acces = 0;
3529     if ((mode & X_OK) && ((stat = access (path, mode)) < 0 || mode == X_OK))
3530       return stat;
3531     if (mode & R_OK)
3532       acces |= CHP$M_READ;
3533     if (mode & W_OK)
3534       acces |= CHP$M_WRITE;
3535     itemlst[0].buflen = sizeof (int);
3536     itemlst[0].code = CHP$_FLAGS;
3537     itemlst[0].bufadr = (char *) &flags;
3538     itemlst[0].retlenadr = &dummy;
3539     itemlst[1].buflen = sizeof (int);
3540     itemlst[1].code = CHP$_ACCESS;
3541     itemlst[1].bufadr = (char *) &acces;
3542     itemlst[1].retlenadr = &dummy;
3543     itemlst[2].end = CHP$_END;
3544     stat = SYS$CHECK_ACCESS (&constant, &path_desc, &user_desc, itemlst);
3545     return stat == SS$_NORMAL ? 0 : -1;
3546   }
3547 }
3548
3549 #else /* not VMS4_4 */
3550
3551 #include <prvdef.h>
3552 #define ACE$M_WRITE     2
3553 #define ACE$C_KEYID     1
3554
3555 static unsigned short memid, grpid;
3556 static unsigned int uic;
3557
3558 /* Called from init_sys_modes, so it happens not very often
3559    but at least each time Emacs is loaded.  */
3560 sys_access_reinit ()
3561 {
3562   uic = 0;
3563 }
3564
3565 int
3566 sys_access (filename, type)
3567      char * filename;
3568      int type;
3569 {
3570   struct FAB fab;
3571   struct XABPRO xab;
3572   int status, size, i, typecode, acl_controlled;
3573   unsigned int *aclptr, *aclend, aclbuf[60];
3574   union prvdef prvmask;
3575
3576   /* Get UIC and GRP values for protection checking.  */
3577   if (uic == 0)
3578     {
3579       status = LIB$GETJPI (&JPI$_UIC, 0, 0, &uic, 0, 0);
3580       if (! (status & 1))
3581         return -1;
3582       memid = uic & 0xFFFF;
3583       grpid = uic >> 16;
3584     }
3585
3586   if (type != 2)                /* not checking write access */
3587     return access (filename, type);
3588
3589   /* Check write protection. */
3590
3591 #define CHECKPRIV(bit)    (prvmask.bit)
3592 #define WRITEABLE(field)  (! ((xab.xab$w_pro >> field) & XAB$M_NOWRITE))
3593
3594   /* Find privilege bits */
3595   status = SYS$SETPRV (0, 0, 0, prvmask);
3596   if (! (status & 1))
3597     error ("Unable to find privileges: %s", vmserrstr (status));
3598   if (CHECKPRIV (PRV$V_BYPASS))
3599     return 0;                   /* BYPASS enabled */
3600   fab = cc$rms_fab;
3601   fab.fab$b_fac = FAB$M_GET;
3602   fab.fab$l_fna = filename;
3603   fab.fab$b_fns = strlen (filename);
3604   fab.fab$l_xab = &xab;
3605   xab = cc$rms_xabpro;
3606   xab.xab$l_aclbuf = aclbuf;
3607   xab.xab$w_aclsiz = sizeof (aclbuf);
3608   status = SYS$OPEN (&fab, 0, 0);
3609   if (! (status & 1))
3610     return -1;
3611   SYS$CLOSE (&fab, 0, 0);
3612   /* Check system access */
3613   if (CHECKPRIV (PRV$V_SYSPRV) && WRITEABLE (XAB$V_SYS))
3614     return 0;
3615   /* Check ACL entries, if any */
3616   acl_controlled = 0;
3617   if (xab.xab$w_acllen > 0)
3618     {
3619       aclptr = aclbuf;
3620       aclend = &aclbuf[xab.xab$w_acllen / 4];
3621       while (*aclptr && aclptr < aclend)
3622         {
3623           size = (*aclptr & 0xff) / 4;
3624           typecode = (*aclptr >> 8) & 0xff;
3625           if (typecode == ACE$C_KEYID)
3626             for (i = size - 1; i > 1; i--)
3627               if (aclptr[i] == uic)
3628                 {
3629                   acl_controlled = 1;
3630                   if (aclptr[1] & ACE$M_WRITE)
3631                     return 0;   /* Write access through ACL */
3632                 }
3633           aclptr = &aclptr[size];
3634         }
3635       if (acl_controlled)       /* ACL specified, prohibits write access */
3636         return -1;
3637     }
3638   /* No ACL entries specified, check normal protection */
3639   if (WRITEABLE (XAB$V_WLD))    /* World writeable */
3640     return 0;
3641   if (WRITEABLE (XAB$V_GRP) &&
3642       (unsigned short) (xab.xab$l_uic >> 16) == grpid)
3643     return 0;                   /* Group writeable */
3644   if (WRITEABLE (XAB$V_OWN) &&
3645       (xab.xab$l_uic & 0xFFFF) == memid)
3646     return 0;                   /* Owner writeable */
3647
3648   return -1;    /* Not writeable */
3649 }
3650 #endif /* not VMS4_4 */
3651 #endif /* access */
3652
3653 static char vtbuf[NAM$C_MAXRSS+1];
3654
3655 /* translate a vms file spec to a unix path */
3656 char *
3657 sys_translate_vms (vfile)
3658      char * vfile;
3659 {
3660   char * p;
3661   char * targ;
3662
3663   if (!vfile)
3664     return 0;
3665
3666   targ = vtbuf;
3667
3668   /* leading device or logical name is a root directory */
3669   if (p = strchr (vfile, ':'))
3670     {
3671       *targ++ = '/';
3672       while (vfile < p)
3673         *targ++ = *vfile++;
3674       vfile++;
3675       *targ++ = '/';
3676     }
3677   p = vfile;
3678   if (*p == '[' || *p == '<')
3679     {
3680       while (*++vfile != *p + 2)
3681         switch (*vfile)
3682           {
3683           case '.':
3684             if (vfile[-1] == *p)
3685               *targ++ = '.';
3686             *targ++ = '/';
3687             break;
3688
3689           case '-':
3690             *targ++ = '.';
3691             *targ++ = '.';
3692             break;
3693
3694           default:
3695             *targ++ = *vfile;
3696             break;
3697           }
3698       vfile++;
3699       *targ++ = '/';
3700     }
3701   while (*vfile)
3702     *targ++ = *vfile++;
3703
3704   return vtbuf;
3705 }
3706
3707 static char utbuf[NAM$C_MAXRSS+1];
3708
3709 /* translate a unix path to a VMS file spec */
3710 char *
3711 sys_translate_unix (ufile)
3712      char * ufile;
3713 {
3714   int slash_seen = 0;
3715   char *p;
3716   char * targ;
3717
3718   if (!ufile)
3719     return 0;
3720
3721   targ = utbuf;
3722
3723   if (*ufile == '/')
3724     {
3725       ufile++;
3726     }
3727
3728   while (*ufile)
3729     {
3730       switch (*ufile)
3731         {
3732         case '/':
3733           if (slash_seen)
3734             if (index (&ufile[1], '/'))
3735               *targ++ = '.';
3736             else
3737               *targ++ = ']';
3738           else
3739             {
3740               *targ++ = ':';
3741               if (index (&ufile[1], '/'))
3742                 *targ++ = '[';
3743               slash_seen = 1;
3744             }
3745           break;
3746
3747         case '.':
3748           if (strncmp (ufile, "./", 2) == 0)
3749             {
3750               if (!slash_seen)
3751                 {
3752                   *targ++ = '[';
3753                   slash_seen = 1;
3754                 }
3755               ufile++;          /* skip the dot */
3756               if (index (&ufile[1], '/'))
3757                 *targ++ = '.';
3758               else
3759                 *targ++ = ']';
3760             }
3761           else if (strncmp (ufile, "../", 3) == 0)
3762             {
3763               if (!slash_seen)
3764                 {
3765                   *targ++ = '[';
3766                   slash_seen = 1;
3767                 }
3768               *targ++ = '-';
3769               ufile += 2;       /* skip the dots */
3770               if (index (&ufile[1], '/'))
3771                 *targ++ = '.';
3772               else
3773                 *targ++ = ']';
3774             }
3775           else
3776             *targ++ = *ufile;
3777           break;
3778
3779         default:
3780           *targ++ = *ufile;
3781           break;
3782         }
3783       ufile++;
3784     }
3785   *targ = '\0';
3786
3787   return utbuf;
3788 }
3789
3790 char *
3791 getwd (pathname)
3792      char *pathname;
3793 {
3794   char *ptr, *val;
3795   extern char *getcwd ();
3796
3797 #define MAXPATHLEN 1024
3798
3799   ptr = xmalloc (MAXPATHLEN);
3800   val = getcwd (ptr, MAXPATHLEN);
3801   if (val == 0)
3802     {
3803       xfree (ptr);
3804       return val;
3805     }
3806   strcpy (pathname, ptr);
3807   xfree (ptr);
3808
3809  return pathname;
3810 }
3811
3812 getppid ()
3813 {
3814   long item_code = JPI$_OWNER;
3815   unsigned long parent_id;
3816   int status;
3817
3818   if (((status = LIB$GETJPI (&item_code, 0, 0, &parent_id)) & 1) == 0)
3819     {
3820       errno = EVMSERR;
3821       vaxc$errno = status;
3822       return -1;
3823     }
3824   return parent_id;
3825 }
3826
3827 #undef getuid
3828 unsigned
3829 sys_getuid ()
3830 {
3831   return (getgid () << 16) | getuid ();
3832 }
3833
3834 int
3835 sys_read (fildes, buf, nbyte)
3836      int fildes;
3837      char *buf;
3838      unsigned int nbyte;
3839 {
3840   return read (fildes, buf, (nbyte < MAXIOSIZE ? nbyte : MAXIOSIZE));
3841 }
3842
3843 #if 0
3844 int
3845 sys_write (fildes, buf, nbyte)
3846      int fildes;
3847      char *buf;
3848      unsigned int nbyte;
3849 {
3850   register int nwrote, rtnval = 0;
3851
3852   while (nbyte > MAXIOSIZE && (nwrote = write (fildes, buf, MAXIOSIZE)) > 0) {
3853     nbyte -= nwrote;
3854     buf += nwrote;
3855     rtnval += nwrote;
3856   }
3857   if (nwrote < 0)
3858     return rtnval ? rtnval : -1;
3859   if ((nwrote = write (fildes, buf, nbyte)) < 0)
3860     return rtnval ? rtnval : -1;
3861   return (rtnval + nwrote);
3862 }
3863 #endif /* 0 */
3864
3865 /*
3866  *      VAX/VMS VAX C RTL really loses. It insists that records
3867  *      end with a newline (carriage return) character, and if they
3868  *      don't it adds one (nice of it isn't it!)
3869  *
3870  *      Thus we do this stupidity below.
3871  */
3872
3873 int
3874 sys_write (fildes, buf, nbytes)
3875      int fildes;
3876      char *buf;
3877      unsigned int nbytes;
3878 {
3879   register char *p;
3880   register char *e;
3881   int sum = 0;
3882   struct stat st;
3883
3884   fstat (fildes, &st);
3885   p = buf;
3886   while (nbytes > 0)
3887     {
3888       int len, retval;
3889
3890       /* Handle fixed-length files with carriage control.  */
3891       if (st.st_fab_rfm == FAB$C_FIX
3892           && ((st.st_fab_rat & (FAB$M_FTN | FAB$M_CR)) != 0))
3893         {
3894           len = st.st_fab_mrs;
3895           retval = write (fildes, p, min (len, nbytes));
3896           if (retval != len)
3897             return -1;
3898           retval++;     /* This skips the implied carriage control */
3899         }
3900       else
3901         {
3902           e =  p + min (MAXIOSIZE, nbytes) - 1;
3903           while (*e != '\n' && e > p) e--;
3904           if (p == e)           /* Ok.. so here we add a newline... sigh. */
3905             e = p + min (MAXIOSIZE, nbytes) - 1;
3906           len = e + 1 - p;
3907           retval = write (fildes, p, len);
3908           if (retval != len)
3909             return -1;
3910         }
3911       p += retval;
3912       sum += retval;
3913       nbytes -= retval;
3914     }
3915   return sum;
3916 }
3917
3918 /* Create file NEW copying its attributes from file OLD.  If
3919    OLD is 0 or does not exist, create based on the value of
3920    vms_stmlf_recfm. */
3921
3922 /* Protection value the file should ultimately have.
3923    Set by create_copy_attrs, and use by rename_sansversions.  */
3924 static unsigned short int fab_final_pro;
3925
3926 int
3927 creat_copy_attrs (old, new)
3928      char *old, *new;
3929 {
3930   struct FAB fab = cc$rms_fab;
3931   struct XABPRO xabpro;
3932   char aclbuf[256];     /* Choice of size is arbitrary.  See below. */
3933   extern int vms_stmlf_recfm;
3934
3935   if (old)
3936     {
3937       fab.fab$b_fac = FAB$M_GET;
3938       fab.fab$l_fna = old;
3939       fab.fab$b_fns = strlen (old);
3940       fab.fab$l_xab = (char *) &xabpro;
3941       xabpro = cc$rms_xabpro;
3942       xabpro.xab$l_aclbuf = aclbuf;
3943       xabpro.xab$w_aclsiz = sizeof aclbuf;
3944       /* Call $OPEN to fill in the fab & xabpro fields. */
3945       if (SYS$OPEN (&fab, 0, 0) & 1)
3946         {
3947           SYS$CLOSE (&fab, 0, 0);
3948           fab.fab$l_alq = 0;    /* zero the allocation quantity */
3949           if (xabpro.xab$w_acllen > 0)
3950             {
3951               if (xabpro.xab$w_acllen > sizeof aclbuf)
3952                 /* If the acl buffer was too short, redo open with longer one.
3953                    Wouldn't need to do this if there were some system imposed
3954                    limit on the size of an ACL, but I can't find any such. */
3955                 {
3956                   xabpro.xab$l_aclbuf = (char *) alloca (xabpro.xab$w_acllen);
3957                   xabpro.xab$w_aclsiz = xabpro.xab$w_acllen;
3958                   if (SYS$OPEN (&fab, 0, 0) & 1)
3959                     SYS$CLOSE (&fab, 0, 0);
3960                   else
3961                     old = 0;
3962                 }
3963             }
3964           else
3965             xabpro.xab$l_aclbuf = 0;
3966         }
3967       else
3968         old = 0;
3969     }
3970   fab.fab$l_fna = new;
3971   fab.fab$b_fns = strlen (new);
3972   if (!old)
3973     {
3974       fab.fab$l_xab = 0;
3975       fab.fab$b_rfm = vms_stmlf_recfm ? FAB$C_STMLF : FAB$C_VAR;
3976       fab.fab$b_rat = FAB$M_CR;
3977     }
3978
3979   /* Set the file protections such that we will be able to manipulate
3980      this file.  Once we are done writing and renaming it, we will set
3981      the protections back.  */
3982   if (old)
3983     fab_final_pro = xabpro.xab$w_pro;
3984   else
3985     SYS$SETDFPROT (0, &fab_final_pro);
3986   xabpro.xab$w_pro &= 0xff0f; /* set O:rewd for now. This is set back later. */
3987
3988   /* Create the new file with either default attrs or attrs copied
3989      from old file. */
3990   if (!(SYS$CREATE (&fab, 0, 0) & 1))
3991     return -1;
3992   SYS$CLOSE (&fab, 0, 0);
3993   /* As this is a "replacement" for creat, return a file descriptor
3994      opened for writing. */
3995   return open (new, O_WRONLY);
3996 }
3997
3998 #ifdef creat
3999 #undef creat
4000 #include <varargs.h>
4001 #ifdef __GNUC__
4002 #ifndef va_count
4003 #define va_count(X) ((X) = *(((int *) &(va_alist)) - 1))
4004 #endif
4005 #endif
4006
4007 sys_creat (va_alist)
4008      va_dcl
4009 {
4010   va_list list_incrementer;
4011   char *name;
4012   int mode;
4013   int rfd;                      /* related file descriptor */
4014   int fd;                       /* Our new file descriptor */
4015   int count;
4016   struct stat st_buf;
4017   char rfm[12];
4018   char rat[15];
4019   char mrs[13];
4020   char fsz[13];
4021   extern int vms_stmlf_recfm;
4022
4023   va_count (count);
4024   va_start (list_incrementer);
4025   name = va_arg (list_incrementer, char *);
4026   mode = va_arg (list_incrementer, int);
4027   if (count > 2)
4028     rfd = va_arg (list_incrementer, int);
4029   va_end (list_incrementer);
4030   if (count > 2)
4031     {
4032       /* Use information from the related file descriptor to set record
4033          format of the newly created file. */
4034       fstat (rfd, &st_buf);
4035       switch (st_buf.st_fab_rfm)
4036         {
4037         case FAB$C_FIX:
4038           strcpy (rfm, "rfm = fix");
4039           sprintf (mrs, "mrs = %d", st_buf.st_fab_mrs);
4040           strcpy (rat, "rat = ");
4041           if (st_buf.st_fab_rat & FAB$M_CR)
4042             strcat (rat, "cr");
4043           else if (st_buf.st_fab_rat & FAB$M_FTN)
4044             strcat (rat, "ftn");
4045           else if (st_buf.st_fab_rat & FAB$M_PRN)
4046             strcat (rat, "prn");
4047           if (st_buf.st_fab_rat & FAB$M_BLK)
4048             if (st_buf.st_fab_rat & (FAB$M_CR|FAB$M_FTN|FAB$M_PRN))
4049               strcat (rat, ", blk");
4050             else
4051               strcat (rat, "blk");
4052           return creat (name, 0, rfm, rat, mrs);
4053
4054         case FAB$C_VFC:
4055           strcpy (rfm, "rfm = vfc");
4056           sprintf (fsz, "fsz = %d", st_buf.st_fab_fsz);
4057           strcpy (rat, "rat = ");
4058           if (st_buf.st_fab_rat & FAB$M_CR)
4059             strcat (rat, "cr");
4060           else if (st_buf.st_fab_rat & FAB$M_FTN)
4061             strcat (rat, "ftn");
4062           else if (st_buf.st_fab_rat & FAB$M_PRN)
4063             strcat (rat, "prn");
4064           if (st_buf.st_fab_rat & FAB$M_BLK)
4065             if (st_buf.st_fab_rat & (FAB$M_CR|FAB$M_FTN|FAB$M_PRN))
4066               strcat (rat, ", blk");
4067             else
4068               strcat (rat, "blk");
4069           return creat (name, 0, rfm, rat, fsz);
4070
4071         case FAB$C_STM:
4072           strcpy (rfm, "rfm = stm");
4073           break;
4074
4075         case FAB$C_STMCR:
4076           strcpy (rfm, "rfm = stmcr");
4077           break;
4078
4079         case FAB$C_STMLF:
4080           strcpy (rfm, "rfm = stmlf");
4081           break;
4082
4083         case FAB$C_UDF:
4084           strcpy (rfm, "rfm = udf");
4085           break;
4086
4087         case FAB$C_VAR:
4088           strcpy (rfm, "rfm = var");
4089           break;
4090         }
4091       strcpy (rat, "rat = ");
4092       if (st_buf.st_fab_rat & FAB$M_CR)
4093         strcat (rat, "cr");
4094       else if (st_buf.st_fab_rat & FAB$M_FTN)
4095         strcat (rat, "ftn");
4096       else if (st_buf.st_fab_rat & FAB$M_PRN)
4097         strcat (rat, "prn");
4098       if (st_buf.st_fab_rat & FAB$M_BLK)
4099         if (st_buf.st_fab_rat & (FAB$M_CR|FAB$M_FTN|FAB$M_PRN))
4100           strcat (rat, ", blk");
4101         else
4102           strcat (rat, "blk");
4103     }
4104   else
4105     {
4106       strcpy (rfm, vms_stmlf_recfm ? "rfm = stmlf" : "rfm=var");
4107       strcpy (rat, "rat=cr");
4108     }
4109   /* Until the VAX C RTL fixes the many bugs with modes, always use
4110      mode 0 to get the user's default protection. */
4111   fd = creat (name, 0, rfm, rat);
4112   if (fd < 0 && errno == EEXIST)
4113     {
4114       if (unlink (name) < 0)
4115         report_file_error ("delete", build_string (name));
4116       fd = creat (name, 0, rfm, rat);
4117     }
4118   return fd;
4119 }
4120 #endif /* creat */
4121
4122 /* fwrite to stdout is S L O W.  Speed it up by using fputc...*/
4123 sys_fwrite (ptr, size, num, fp)
4124      register char * ptr;
4125      FILE * fp;
4126 {
4127   register int tot = num * size;
4128
4129   while (tot--)
4130     fputc (*ptr++, fp);
4131 }
4132
4133 /*
4134  * The VMS C library routine creat actually creates a new version of an
4135  * existing file rather than truncating the old version.  There are times
4136  * when this is not the desired behavior, for instance, when writing an
4137  * auto save file (you only want one version), or when you don't have
4138  * write permission in the directory containing the file (but the file
4139  * itself is writable).  Hence this routine, which is equivalent to
4140  * "close (creat (fn, 0));" on Unix if fn already exists.
4141  */
4142 int
4143 vms_truncate (fn)
4144      char *fn;
4145 {
4146   struct FAB xfab = cc$rms_fab;
4147   struct RAB xrab = cc$rms_rab;
4148   int status;
4149
4150   xfab.fab$l_fop = FAB$M_TEF;   /* free allocated but unused blocks on close */
4151   xfab.fab$b_fac = FAB$M_TRN | FAB$M_GET; /* allow truncate and get access */
4152   xfab.fab$b_shr = FAB$M_NIL;   /* allow no sharing - file must be locked */
4153   xfab.fab$l_fna = fn;
4154   xfab.fab$b_fns = strlen (fn);
4155   xfab.fab$l_dna = ";0";        /* default to latest version of the file */
4156   xfab.fab$b_dns = 2;
4157   xrab.rab$l_fab = &xfab;
4158
4159   /* This gibberish opens the file, positions to the first record, and
4160      deletes all records from there until the end of file. */
4161   if ((SYS$OPEN (&xfab) & 01) == 01)
4162     {
4163       if ((SYS$CONNECT (&xrab) & 01) == 01 &&
4164           (SYS$FIND (&xrab) & 01) == 01 &&
4165           (SYS$TRUNCATE (&xrab) & 01) == 01)
4166         status = 0;
4167       else
4168         status = -1;
4169     }
4170   else
4171     status = -1;
4172   SYS$CLOSE (&xfab);
4173   return status;
4174 }
4175
4176 /* Define this symbol to actually read SYSUAF.DAT.  This requires either
4177    SYSPRV or a readable SYSUAF.DAT. */
4178
4179 #ifdef READ_SYSUAF
4180 /*
4181  * getuaf.c
4182  *
4183  * Routine to read the VMS User Authorization File and return
4184  * a specific user's record.
4185  */
4186
4187 static struct UAF retuaf;
4188
4189 struct UAF *
4190 get_uaf_name (uname)
4191      char * uname;
4192 {
4193   register status;
4194   struct FAB uaf_fab;
4195   struct RAB uaf_rab;
4196
4197   uaf_fab = cc$rms_fab;
4198   uaf_rab = cc$rms_rab;
4199   /* initialize fab fields */
4200   uaf_fab.fab$l_fna = "SYS$SYSTEM:SYSUAF.DAT";
4201   uaf_fab.fab$b_fns = 21;
4202   uaf_fab.fab$b_fac = FAB$M_GET;
4203   uaf_fab.fab$b_org = FAB$C_IDX;
4204   uaf_fab.fab$b_shr = FAB$M_GET|FAB$M_PUT|FAB$M_UPD|FAB$M_DEL;
4205   /* initialize rab fields */
4206   uaf_rab.rab$l_fab = &uaf_fab;
4207   /* open the User Authorization File */
4208   status = SYS$OPEN (&uaf_fab);
4209   if (!(status&1))
4210     {
4211       errno = EVMSERR;
4212       vaxc$errno = status;
4213       return 0;
4214     }
4215   status = SYS$CONNECT (&uaf_rab);
4216   if (!(status&1))
4217     {
4218       errno = EVMSERR;
4219       vaxc$errno = status;
4220       return 0;
4221     }
4222   /* read the requested record - index is in uname */
4223   uaf_rab.rab$l_kbf = uname;
4224   uaf_rab.rab$b_ksz = strlen (uname);
4225   uaf_rab.rab$b_rac = RAB$C_KEY;
4226   uaf_rab.rab$l_ubf = (char *)&retuaf;
4227   uaf_rab.rab$w_usz = sizeof retuaf;
4228   status = SYS$GET (&uaf_rab);
4229   if (!(status&1))
4230     {
4231       errno = EVMSERR;
4232       vaxc$errno = status;
4233       return 0;
4234     }
4235   /* close the User Authorization File */
4236   status = SYS$DISCONNECT (&uaf_rab);
4237   if (!(status&1))
4238     {
4239       errno = EVMSERR;
4240       vaxc$errno = status;
4241       return 0;
4242     }
4243   status = SYS$CLOSE (&uaf_fab);
4244   if (!(status&1))
4245     {
4246       errno = EVMSERR;
4247       vaxc$errno = status;
4248       return 0;
4249     }
4250   return &retuaf;
4251 }
4252
4253 struct UAF *
4254 get_uaf_uic (uic)
4255      unsigned long uic;
4256 {
4257   register status;
4258   struct FAB uaf_fab;
4259   struct RAB uaf_rab;
4260
4261   uaf_fab = cc$rms_fab;
4262   uaf_rab = cc$rms_rab;
4263   /* initialize fab fields */
4264   uaf_fab.fab$l_fna = "SYS$SYSTEM:SYSUAF.DAT";
4265   uaf_fab.fab$b_fns = 21;
4266   uaf_fab.fab$b_fac = FAB$M_GET;
4267   uaf_fab.fab$b_org = FAB$C_IDX;
4268   uaf_fab.fab$b_shr = FAB$M_GET|FAB$M_PUT|FAB$M_UPD|FAB$M_DEL;
4269   /* initialize rab fields */
4270   uaf_rab.rab$l_fab = &uaf_fab;
4271   /* open the User Authorization File */
4272   status = SYS$OPEN (&uaf_fab);
4273   if (!(status&1))
4274     {
4275       errno = EVMSERR;
4276       vaxc$errno = status;
4277       return 0;
4278     }
4279   status = SYS$CONNECT (&uaf_rab);
4280   if (!(status&1))
4281     {
4282       errno = EVMSERR;
4283       vaxc$errno = status;
4284       return 0;
4285     }
4286   /* read the requested record - index is in uic */
4287   uaf_rab.rab$b_krf = 1;        /* 1st alternate key */
4288   uaf_rab.rab$l_kbf = (char *) &uic;
4289   uaf_rab.rab$b_ksz = sizeof uic;
4290   uaf_rab.rab$b_rac = RAB$C_KEY;
4291   uaf_rab.rab$l_ubf = (char *)&retuaf;
4292   uaf_rab.rab$w_usz = sizeof retuaf;
4293   status = SYS$GET (&uaf_rab);
4294   if (!(status&1))
4295     {
4296       errno = EVMSERR;
4297       vaxc$errno = status;
4298       return 0;
4299     }
4300   /* close the User Authorization File */
4301   status = SYS$DISCONNECT (&uaf_rab);
4302   if (!(status&1))
4303     {
4304       errno = EVMSERR;
4305       vaxc$errno = status;
4306       return 0;
4307     }
4308   status = SYS$CLOSE (&uaf_fab);
4309   if (!(status&1))
4310     {
4311       errno = EVMSERR;
4312       vaxc$errno = status;
4313       return 0;
4314     }
4315   return &retuaf;
4316 }
4317
4318 static struct passwd retpw;
4319
4320 struct passwd *
4321 cnv_uaf_pw (up)
4322      struct UAF * up;
4323 {
4324   char * ptr;
4325
4326   /* copy these out first because if the username is 32 chars, the next
4327      section will overwrite the first byte of the UIC */
4328   retpw.pw_uid = up->uaf$w_mem;
4329   retpw.pw_gid = up->uaf$w_grp;
4330
4331   /* I suppose this is not the best sytle, to possibly overwrite one
4332      byte beyond the end of the field, but what the heck... */
4333   ptr = &up->uaf$t_username[UAF$S_USERNAME];
4334   while (ptr[-1] == ' ')
4335     ptr--;
4336   *ptr = '\0';
4337   strcpy (retpw.pw_name, up->uaf$t_username);
4338
4339   /* the rest of these are counted ascii strings */
4340   strncpy (retpw.pw_gecos, &up->uaf$t_owner[1], up->uaf$t_owner[0]);
4341   retpw.pw_gecos[up->uaf$t_owner[0]] = '\0';
4342   strncpy (retpw.pw_dir, &up->uaf$t_defdev[1], up->uaf$t_defdev[0]);
4343   retpw.pw_dir[up->uaf$t_defdev[0]] = '\0';
4344   strncat (retpw.pw_dir, &up->uaf$t_defdir[1], up->uaf$t_defdir[0]);
4345   retpw.pw_dir[up->uaf$t_defdev[0] + up->uaf$t_defdir[0]] = '\0';
4346   strncpy (retpw.pw_shell, &up->uaf$t_defcli[1], up->uaf$t_defcli[0]);
4347   retpw.pw_shell[up->uaf$t_defcli[0]] = '\0';
4348
4349   return &retpw;
4350 }
4351 #else /* not READ_SYSUAF */
4352 static struct passwd retpw;
4353 #endif /* not READ_SYSUAF */
4354
4355 struct passwd *
4356 getpwnam (name)
4357      char * name;
4358 {
4359 #ifdef READ_SYSUAF
4360   struct UAF *up;
4361 #else
4362   char * user;
4363   char * dir;
4364   unsigned char * full;
4365 #endif /* READ_SYSUAF */
4366   char *ptr = name;
4367
4368   while (*ptr)
4369     {
4370       if ('a' <= *ptr && *ptr <= 'z')
4371         *ptr -= 040;
4372       ptr++;
4373     }
4374 #ifdef READ_SYSUAF
4375   if (!(up = get_uaf_name (name)))
4376     return 0;
4377   return cnv_uaf_pw (up);
4378 #else
4379   if (strcmp (name, getenv ("USER")) == 0)
4380     {
4381       retpw.pw_uid = getuid ();
4382       retpw.pw_gid = getgid ();
4383       strcpy (retpw.pw_name, name);
4384       if (full = egetenv ("FULLNAME"))
4385         strcpy (retpw.pw_gecos, full);
4386       else
4387         *retpw.pw_gecos = '\0';
4388       strcpy (retpw.pw_dir, egetenv ("HOME"));
4389       *retpw.pw_shell = '\0';
4390       return &retpw;
4391     }
4392   else
4393     return 0;
4394 #endif /* not READ_SYSUAF */
4395 }
4396
4397 struct passwd *
4398 getpwuid (uid)
4399      unsigned long uid;
4400 {
4401 #ifdef READ_SYSUAF
4402   struct UAF * up;
4403
4404   if (!(up = get_uaf_uic (uid)))
4405     return 0;
4406   return cnv_uaf_pw (up);
4407 #else
4408   if (uid == sys_getuid ())
4409     return getpwnam (egetenv ("USER"));
4410   else
4411     return 0;
4412 #endif /* not READ_SYSUAF */
4413 }
4414
4415 /* return total address space available to the current process.  This is
4416    the sum of the current p0 size, p1 size and free page table entries
4417    available. */
4418 vlimit ()
4419 {
4420   int item_code;
4421   unsigned long free_pages;
4422   unsigned long frep0va;
4423   unsigned long frep1va;
4424   register status;
4425
4426   item_code = JPI$_FREPTECNT;
4427   if (((status = LIB$GETJPI (&item_code, 0, 0, &free_pages)) & 1) == 0)
4428     {
4429       errno = EVMSERR;
4430       vaxc$errno = status;
4431       return -1;
4432     }
4433   free_pages *= 512;
4434
4435   item_code = JPI$_FREP0VA;
4436   if (((status = LIB$GETJPI (&item_code, 0, 0, &frep0va)) & 1) == 0)
4437     {
4438       errno = EVMSERR;
4439       vaxc$errno = status;
4440       return -1;
4441     }
4442   item_code = JPI$_FREP1VA;
4443   if (((status = LIB$GETJPI (&item_code, 0, 0, &frep1va)) & 1) == 0)
4444     {
4445       errno = EVMSERR;
4446       vaxc$errno = status;
4447       return -1;
4448     }
4449
4450   return free_pages + frep0va + (0x7fffffff - frep1va);
4451 }
4452
4453 define_logical_name (varname, string)
4454      char *varname;
4455      char *string;
4456 {
4457   struct dsc$descriptor_s strdsc =
4458     {strlen (string), DSC$K_DTYPE_T, DSC$K_CLASS_S, string};
4459   struct dsc$descriptor_s envdsc =
4460     {strlen (varname), DSC$K_DTYPE_T, DSC$K_CLASS_S, varname};
4461   struct dsc$descriptor_s lnmdsc =
4462     {7, DSC$K_DTYPE_T, DSC$K_CLASS_S, "LNM$JOB"};
4463
4464   return LIB$SET_LOGICAL (&envdsc, &strdsc, &lnmdsc, 0, 0);
4465 }
4466
4467 delete_logical_name (varname)
4468      char *varname;
4469 {
4470   struct dsc$descriptor_s envdsc =
4471     {strlen (varname), DSC$K_DTYPE_T, DSC$K_CLASS_S, varname};
4472   struct dsc$descriptor_s lnmdsc =
4473     {7, DSC$K_DTYPE_T, DSC$K_CLASS_S, "LNM$JOB"};
4474
4475   return LIB$DELETE_LOGICAL (&envdsc, &lnmdsc);
4476 }
4477
4478 ulimit ()
4479 {}
4480
4481 setpgrp ()
4482 {}
4483
4484 execvp ()
4485 {
4486   error ("execvp system call not implemented");
4487 }
4488
4489 int
4490 rename (from, to)
4491      char *from, *to;
4492 {
4493   int status;
4494   struct FAB from_fab = cc$rms_fab, to_fab = cc$rms_fab;
4495   struct NAM from_nam = cc$rms_nam, to_nam = cc$rms_nam;
4496   char from_esn[NAM$C_MAXRSS];
4497   char to_esn[NAM$C_MAXRSS];
4498
4499   from_fab.fab$l_fna = from;
4500   from_fab.fab$b_fns = strlen (from);
4501   from_fab.fab$l_nam = &from_nam;
4502   from_fab.fab$l_fop = FAB$M_NAM;
4503
4504   from_nam.nam$l_esa = from_esn;
4505   from_nam.nam$b_ess = sizeof from_esn;
4506
4507   to_fab.fab$l_fna = to;
4508   to_fab.fab$b_fns = strlen (to);
4509   to_fab.fab$l_nam = &to_nam;
4510   to_fab.fab$l_fop = FAB$M_NAM;
4511
4512   to_nam.nam$l_esa = to_esn;
4513   to_nam.nam$b_ess = sizeof to_esn;
4514
4515   status = SYS$RENAME (&from_fab, 0, 0, &to_fab);
4516
4517   if (status & 1)
4518     return 0;
4519   else
4520     {
4521       if (status == RMS$_DEV)
4522         errno = EXDEV;
4523       else
4524         errno = EVMSERR;
4525       vaxc$errno = status;
4526       return -1;
4527     }
4528 }
4529
4530 /* This function renames a file like `rename', but it strips
4531    the version number from the "to" filename, such that the "to" file is
4532    will always be a new version.  It also sets the file protection once it is
4533    finished.  The protection that we will use is stored in fab_final_pro,
4534    and was set when we did a creat_copy_attrs to create the file that we
4535    are renaming.
4536
4537    We could use the chmod function, but Eunichs uses 3 bits per user category
4538    to describe the protection, and VMS uses 4 (write and delete are separate
4539    bits).  To maintain portability, the VMS implementation of `chmod' wires
4540    the W and D bits together.  */
4541
4542
4543 static struct fibdef fib;       /* We need this initialized to zero */
4544 char vms_file_written[NAM$C_MAXRSS];
4545
4546 int
4547 rename_sans_version (from,to)
4548      char *from, *to;
4549 {
4550   short int chan;
4551   int stat;
4552   short int iosb[4];
4553   int status;
4554   struct FAB to_fab = cc$rms_fab;
4555   struct NAM to_nam = cc$rms_nam;
4556   struct dsc$descriptor fib_d ={sizeof (fib),0,0,(char*) &fib};
4557   struct dsc$descriptor fib_attr[2]
4558     = {{sizeof (fab_final_pro),ATR$C_FPRO,0,(char*) &fab_final_pro},{0,0,0,0}};
4559   char to_esn[NAM$C_MAXRSS];
4560
4561   $DESCRIPTOR (disk,to_esn);
4562
4563   to_fab.fab$l_fna = to;
4564   to_fab.fab$b_fns = strlen (to);
4565   to_fab.fab$l_nam = &to_nam;
4566   to_fab.fab$l_fop = FAB$M_NAM;
4567
4568   to_nam.nam$l_esa = to_esn;
4569   to_nam.nam$b_ess = sizeof to_esn;
4570
4571   status = SYS$PARSE (&to_fab, 0, 0); /* figure out the full file name */
4572
4573   if (to_nam.nam$l_fnb && NAM$M_EXP_VER)
4574     *(to_nam.nam$l_ver) = '\0';
4575
4576   stat = rename (from, to_esn);
4577   if (stat < 0)
4578     return stat;
4579
4580   strcpy (vms_file_written, to_esn);
4581
4582   to_fab.fab$l_fna = vms_file_written; /* this points to the versionless name */
4583   to_fab.fab$b_fns = strlen (vms_file_written);
4584
4585   /* Now set the file protection to the correct value */
4586   SYS$OPEN (&to_fab, 0, 0);     /* This fills in the nam$w_fid fields */
4587
4588   /* Copy these fields into the fib */
4589   fib.fib$r_fid_overlay.fib$w_fid[0] = to_nam.nam$w_fid[0];
4590   fib.fib$r_fid_overlay.fib$w_fid[1] = to_nam.nam$w_fid[1];
4591   fib.fib$r_fid_overlay.fib$w_fid[2] = to_nam.nam$w_fid[2];
4592
4593   SYS$CLOSE (&to_fab, 0, 0);
4594
4595   stat = SYS$ASSIGN (&disk, &chan, 0, 0); /* open a channel to the disk */
4596   if (!stat)
4597     LIB$SIGNAL (stat);
4598   stat = SYS$QIOW (0, chan, IO$_MODIFY, iosb, 0, 0, &fib_d,
4599                    0, 0, 0, &fib_attr, 0);
4600   if (!stat)
4601     LIB$SIGNAL (stat);
4602   stat = SYS$DASSGN (chan);
4603   if (!stat)
4604     LIB$SIGNAL (stat);
4605   strcpy (vms_file_written, to_esn); /* We will write this to the terminal*/
4606   return 0;
4607 }
4608
4609 link (file, new)
4610      char * file, * new;
4611 {
4612   register status;
4613   struct FAB fab;
4614   struct NAM nam;
4615   unsigned short fid[3];
4616   char esa[NAM$C_MAXRSS];
4617
4618   fab = cc$rms_fab;
4619   fab.fab$l_fop = FAB$M_OFP;
4620   fab.fab$l_fna = file;
4621   fab.fab$b_fns = strlen (file);
4622   fab.fab$l_nam = &nam;
4623
4624   nam = cc$rms_nam;
4625   nam.nam$l_esa = esa;
4626   nam.nam$b_ess = NAM$C_MAXRSS;
4627
4628   status = SYS$PARSE (&fab);
4629   if ((status & 1) == 0)
4630     {
4631       errno = EVMSERR;
4632       vaxc$errno = status;
4633       return -1;
4634     }
4635   status = SYS$SEARCH (&fab);
4636   if ((status & 1) == 0)
4637     {
4638       errno = EVMSERR;
4639       vaxc$errno = status;
4640       return -1;
4641     }
4642
4643   fid[0] = nam.nam$w_fid[0];
4644   fid[1] = nam.nam$w_fid[1];
4645   fid[2] = nam.nam$w_fid[2];
4646
4647   fab.fab$l_fna = new;
4648   fab.fab$b_fns = strlen (new);
4649
4650   status = SYS$PARSE (&fab);
4651   if ((status & 1) == 0)
4652     {
4653       errno = EVMSERR;
4654       vaxc$errno = status;
4655       return -1;
4656     }
4657
4658   nam.nam$w_fid[0] = fid[0];
4659   nam.nam$w_fid[1] = fid[1];
4660   nam.nam$w_fid[2] = fid[2];
4661
4662   nam.nam$l_esa = nam.nam$l_name;
4663   nam.nam$b_esl = nam.nam$b_name + nam.nam$b_type + nam.nam$b_ver;
4664
4665   status = SYS$ENTER (&fab);
4666   if ((status & 1) == 0)
4667     {
4668       errno = EVMSERR;
4669       vaxc$errno = status;
4670       return -1;
4671     }
4672
4673   return 0;
4674 }
4675
4676 croak (badfunc)
4677      char *badfunc;
4678 {
4679   printf ("%s not yet implemented\r\n", badfunc);
4680   reset_sys_modes ();
4681   exit (1);
4682 }
4683
4684 long
4685 random ()
4686 {
4687   /* Arrange to return a range centered on zero.  */
4688   return rand () - (1 << 30);
4689 }
4690
4691 srandom (seed)
4692 {
4693   srand (seed);
4694 }
4695 #endif /* VMS */
4696 \f
4697 #ifdef AIX
4698
4699 /* Called from init_sys_modes.  */
4700 hft_init ()
4701 {
4702   int junk;
4703
4704   /* If we're not on an HFT we shouldn't do any of this.  We determine
4705      if we are on an HFT by trying to get an HFT error code.  If this
4706      call fails, we're not on an HFT. */
4707 #ifdef IBMR2AIX
4708   if (ioctl (0, HFQERROR, &junk) < 0)
4709     return;
4710 #else /* not IBMR2AIX */
4711   if (ioctl (0, HFQEIO, 0) < 0)
4712     return;
4713 #endif /* not IBMR2AIX */
4714
4715   /* On AIX the default hft keyboard mapping uses backspace rather than delete
4716      as the rubout key's ASCII code.  Here this is changed.  The bug is that
4717      there's no way to determine the old mapping, so in reset_sys_modes
4718      we need to assume that the normal map had been present.  Of course, this
4719      code also doesn't help if on a terminal emulator which doesn't understand
4720      HFT VTD's. */
4721   {
4722     struct hfbuf buf;
4723     struct hfkeymap keymap;
4724
4725     buf.hf_bufp = (char *)&keymap;
4726     buf.hf_buflen = sizeof (keymap);
4727     keymap.hf_nkeys = 2;
4728     keymap.hfkey[0].hf_kpos = 15;
4729     keymap.hfkey[0].hf_kstate = HFMAPCHAR | HFSHFNONE;
4730 #ifdef IBMR2AIX
4731     keymap.hfkey[0].hf_keyidh = '<';
4732 #else /* not IBMR2AIX */
4733     keymap.hfkey[0].hf_page = '<';
4734 #endif /* not IBMR2AIX */
4735     keymap.hfkey[0].hf_char = 127;
4736     keymap.hfkey[1].hf_kpos = 15;
4737     keymap.hfkey[1].hf_kstate = HFMAPCHAR | HFSHFSHFT;
4738 #ifdef IBMR2AIX
4739     keymap.hfkey[1].hf_keyidh = '<';
4740 #else /* not IBMR2AIX */
4741     keymap.hfkey[1].hf_page = '<';
4742 #endif /* not IBMR2AIX */
4743     keymap.hfkey[1].hf_char = 127;
4744     hftctl (0, HFSKBD, &buf);
4745   }
4746   /* The HFT system on AIX doesn't optimize for scrolling, so it's really ugly
4747      at times.  */
4748   line_ins_del_ok = char_ins_del_ok = 0;
4749 }
4750
4751 /* Reset the rubout key to backspace. */
4752
4753 hft_reset ()
4754 {
4755   struct hfbuf buf;
4756   struct hfkeymap keymap;
4757   int junk;
4758
4759 #ifdef IBMR2AIX
4760   if (ioctl (0, HFQERROR, &junk) < 0)
4761     return;
4762 #else /* not IBMR2AIX */
4763   if (ioctl (0, HFQEIO, 0) < 0)
4764     return;
4765 #endif /* not IBMR2AIX */
4766
4767   buf.hf_bufp = (char *)&keymap;
4768   buf.hf_buflen = sizeof (keymap);
4769   keymap.hf_nkeys = 2;
4770   keymap.hfkey[0].hf_kpos = 15;
4771   keymap.hfkey[0].hf_kstate = HFMAPCHAR | HFSHFNONE;
4772 #ifdef IBMR2AIX
4773   keymap.hfkey[0].hf_keyidh = '<';
4774 #else /* not IBMR2AIX */
4775   keymap.hfkey[0].hf_page = '<';
4776 #endif /* not IBMR2AIX */
4777   keymap.hfkey[0].hf_char = 8;
4778   keymap.hfkey[1].hf_kpos = 15;
4779   keymap.hfkey[1].hf_kstate = HFMAPCHAR | HFSHFSHFT;
4780 #ifdef IBMR2AIX
4781   keymap.hfkey[1].hf_keyidh = '<';
4782 #else /* not IBMR2AIX */
4783   keymap.hfkey[1].hf_page = '<';
4784 #endif /* not IBMR2AIX */
4785   keymap.hfkey[1].hf_char = 8;
4786   hftctl (0, HFSKBD, &buf);
4787 }
4788
4789 #endif /* AIX */