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