src/sysdep.c

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