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   "Special Signal Used By CPR",     /* 34 SIGFREEZE */
2939   "Special Signal Used By CPR",     /* 35 SIGTHAW */
2940 #endif /* sun */
2941 #endif /* not AIX */
2942   0
2943   };
2944 #endif /* HAVE_SYS_SIGLIST */
2945
2946 /*
2947  *      Warning, this function may not duplicate 4.2 action properly
2948  *      under error conditions.
2949  */
2950
2951 #ifndef MAXPATHLEN
2952 /* In 4.1, param.h fails to define this.  */
2953 #define MAXPATHLEN 1024
2954 #endif
2955
2956 #ifndef HAVE_GETWD
2957
2958 char *
2959 getwd (pathname)
2960      char *pathname;
2961 {
2962   char *npath, *spath;
2963   extern char *getcwd ();
2964
2965   BLOCK_INPUT;                  /* getcwd uses malloc */
2966   spath = npath = getcwd ((char *) 0, MAXPATHLEN);
2967   if (spath == 0)
2968     return spath;
2969   /* On Altos 3068, getcwd can return @hostname/dir, so discard
2970      up to first slash.  Should be harmless on other systems.  */
2971   while (*npath && *npath != '/')
2972     npath++;
2973   strcpy (pathname, npath);
2974   free (spath);                 /* getcwd uses malloc */
2975   UNBLOCK_INPUT;
2976   return pathname;
2977 }
2978
2979 #endif /* HAVE_GETWD */
2980
2981 /*
2982  *      Emulate rename using unlink/link.  Note that this is
2983  *      only partially correct.  Also, doesn't enforce restriction
2984  *      that files be of same type (regular->regular, dir->dir, etc).
2985  */
2986
2987 #ifndef HAVE_RENAME
2988
2989 rename (from, to)
2990      const char *from;
2991      const char *to;
2992 {
2993   if (access (from, 0) == 0)
2994     {
2995       unlink (to);
2996       if (link (from, to) == 0)
2997         if (unlink (from) == 0)
2998           return (0);
2999     }
3000   return (-1);
3001 }
3002
3003 #endif
3004
3005 #ifdef MISSING_UTIMES
3006
3007 /* HPUX (among others) sets HAVE_TIMEVAL but does not implement utimes.  */
3008
3009 utimes ()
3010 {
3011 }
3012 #endif
3013
3014 #ifdef IRIS_UTIME
3015
3016 /* The IRIS (3.5) has timevals, but uses sys V utime, and doesn't have the
3017    utimbuf structure defined anywhere but in the man page. */
3018
3019 struct utimbuf
3020  {
3021    long actime;
3022    long modtime;
3023  };
3024
3025 utimes (name, tvp)
3026      char *name;
3027      struct timeval tvp[];
3028 {
3029   struct utimbuf utb;
3030   utb.actime  = tvp[0].tv_sec;
3031   utb.modtime = tvp[1].tv_sec;
3032   utime (name, &utb);
3033 }
3034 #endif /* IRIS_UTIME */
3035
3036
3037 #ifdef HPUX
3038 #ifndef HAVE_PERROR
3039
3040 /* HPUX curses library references perror, but as far as we know
3041    it won't be called.  Anyway this definition will do for now.  */
3042
3043 perror ()
3044 {
3045 }
3046
3047 #endif /* not HAVE_PERROR */
3048 #endif /* HPUX */
3049
3050 #ifndef HAVE_DUP2
3051
3052 /*
3053  *      Emulate BSD dup2.  First close newd if it already exists.
3054  *      Then, attempt to dup oldd.  If not successful, call dup2 recursively
3055  *      until we are, then close the unsuccessful ones.
3056  */
3057
3058 dup2 (oldd, newd)
3059      int oldd;
3060      int newd;
3061 {
3062   register int fd, ret;
3063
3064   sys_close (newd);
3065
3066 #ifdef F_DUPFD
3067   fd = fcntl (oldd, F_DUPFD, newd);
3068   if (fd != newd)
3069     error ("can't dup2 (%i,%i) : %s", oldd, newd, strerror (errno));
3070 #else
3071   fd = dup (old);
3072   if (fd == -1)
3073     return -1;
3074   if (fd == new)
3075     return new;
3076   ret = dup2 (old,new);
3077   sys_close (fd);
3078   return ret;
3079 #endif
3080 }
3081
3082 #endif /* not HAVE_DUP2 */
3083
3084 /*
3085  *      Gettimeofday.  Simulate as much as possible.  Only accurate
3086  *      to nearest second.  Emacs doesn't use tzp so ignore it for now.
3087  *      Only needed when subprocesses are defined.
3088  */
3089
3090 #ifdef subprocesses
3091 #ifndef VMS
3092 #ifndef HAVE_GETTIMEOFDAY
3093 #ifdef HAVE_TIMEVAL
3094
3095 /* ARGSUSED */
3096 gettimeofday (tp, tzp)
3097      struct timeval *tp;
3098      struct timezone *tzp;
3099 {
3100   extern long time ();
3101
3102   tp->tv_sec = time ((long *)0);
3103   tp->tv_usec = 0;
3104   if (tzp != 0)
3105     tzp->tz_minuteswest = -1;
3106 }
3107
3108 #endif
3109 #endif
3110 #endif
3111 #endif /* subprocess && !HAVE_GETTIMEOFDAY && HAVE_TIMEVAL && !VMS */
3112
3113 /*
3114  *      This function will go away as soon as all the stubs fixed. (fnf)
3115  */
3116
3117 croak (badfunc)
3118      char *badfunc;
3119 {
3120   printf ("%s not yet implemented\r\n", badfunc);
3121   reset_sys_modes ();
3122   exit (1);
3123 }
3124
3125 #endif /* USG */
3126 \f
3127 #ifdef DGUX
3128
3129 char *sys_siglist[NSIG + 1] =
3130 {
3131   "null signal",                         /*  0 SIGNULL   */
3132   "hangup",                              /*  1 SIGHUP    */
3133   "interrupt",                           /*  2 SIGINT    */
3134   "quit",                                /*  3 SIGQUIT   */
3135   "illegal instruction",                 /*  4 SIGILL    */
3136   "trace trap",                          /*  5 SIGTRAP   */
3137   "abort termination",                   /*  6 SIGABRT   */
3138   "SIGEMT",                              /*  7 SIGEMT    */
3139   "floating point exception",            /*  8 SIGFPE    */
3140   "kill",                                /*  9 SIGKILL   */
3141   "bus error",                           /* 10 SIGBUS    */
3142   "segmentation violation",              /* 11 SIGSEGV   */
3143   "bad argument to system call",         /* 12 SIGSYS    */
3144   "write on a pipe with no reader",      /* 13 SIGPIPE   */
3145   "alarm clock",                         /* 14 SIGALRM   */
3146   "software termination signal",         /* 15 SIGTERM   */
3147   "user defined signal 1",               /* 16 SIGUSR1   */
3148   "user defined signal 2",               /* 17 SIGUSR2   */
3149   "child stopped or terminated",         /* 18 SIGCLD    */
3150   "power-fail restart",                  /* 19 SIGPWR    */
3151   "window size changed",                 /* 20 SIGWINCH  */
3152   "undefined",                           /* 21           */
3153   "pollable event occurred",             /* 22 SIGPOLL   */
3154   "sendable stop signal not from tty",   /* 23 SIGSTOP   */
3155   "stop signal from tty",                /* 24 SIGSTP    */
3156   "continue a stopped process",          /* 25 SIGCONT   */
3157   "attempted background tty read",       /* 26 SIGTTIN   */
3158   "attempted background tty write",      /* 27 SIGTTOU   */
3159   "undefined",                           /* 28           */
3160   "undefined",                           /* 29           */
3161   "undefined",                           /* 30           */
3162   "undefined",                           /* 31           */
3163   "undefined",                           /* 32           */
3164   "socket (TCP/IP) urgent data arrival", /* 33 SIGURG    */
3165   "I/O is possible",                     /* 34 SIGIO     */
3166   "exceeded cpu time limit",             /* 35 SIGXCPU   */
3167   "exceeded file size limit",            /* 36 SIGXFSZ   */
3168   "virtual time alarm",                  /* 37 SIGVTALRM */
3169   "profiling time alarm",                /* 38 SIGPROF   */
3170   "undefined",                           /* 39           */
3171   "file record locks revoked",           /* 40 SIGLOST   */
3172   "undefined",                           /* 41           */
3173   "undefined",                           /* 42           */
3174   "undefined",                           /* 43           */
3175   "undefined",                           /* 44           */
3176   "undefined",                           /* 45           */
3177   "undefined",                           /* 46           */
3178   "undefined",                           /* 47           */
3179   "undefined",                           /* 48           */
3180   "undefined",                           /* 49           */
3181   "undefined",                           /* 50           */
3182   "undefined",                           /* 51           */
3183   "undefined",                           /* 52           */
3184   "undefined",                           /* 53           */
3185   "undefined",                           /* 54           */
3186   "undefined",                           /* 55           */
3187   "undefined",                           /* 56           */
3188   "undefined",                           /* 57           */
3189   "undefined",                           /* 58           */
3190   "undefined",                           /* 59           */
3191   "undefined",                           /* 60           */
3192   "undefined",                           /* 61           */
3193   "undefined",                           /* 62           */
3194   "undefined",                           /* 63           */
3195   "notification message in mess. queue", /* 64 SIGDGNOTIFY */
3196   0
3197 };
3198
3199 #endif /* DGUX */
3200 \f
3201 /* Directory routines for systems that don't have them. */
3202
3203 #ifdef SYSV_SYSTEM_DIR
3204
3205 #include <dirent.h>
3206
3207 #if defined(BROKEN_CLOSEDIR) || !defined(HAVE_CLOSEDIR)
3208
3209 int
3210 closedir (dirp)
3211      register DIR *dirp;              /* stream from opendir */
3212 {
3213   int rtnval;
3214
3215   rtnval = sys_close (dirp->dd_fd);
3216
3217   /* Some systems (like Solaris) allocate the buffer and the DIR all
3218      in one block.  Why in the world are we freeing this ourselves
3219      anyway?  */
3220 #if ! (defined (sun) && defined (USG5_4))
3221   xfree ((char *) dirp->dd_buf); /* directory block defined in <dirent.h> */
3222 #endif
3223   xfree ((char *) dirp);
3224
3225   return rtnval;
3226 }
3227 #endif /* BROKEN_CLOSEDIR or not HAVE_CLOSEDIR */
3228 #endif /* SYSV_SYSTEM_DIR */
3229
3230 #ifdef NONSYSTEM_DIR_LIBRARY
3231
3232 DIR *
3233 opendir (filename)
3234      char *filename;    /* name of directory */
3235 {
3236   register DIR *dirp;           /* -> malloc'ed storage */
3237   register int fd;              /* file descriptor for read */
3238   struct stat sbuf;             /* result of fstat */
3239
3240   fd = sys_open (filename, 0);
3241   if (fd < 0)
3242     return 0;
3243
3244   BLOCK_INPUT;
3245   if (fstat (fd, &sbuf) < 0
3246       || (sbuf.st_mode & S_IFMT) != S_IFDIR
3247       || (dirp = (DIR *) malloc (sizeof (DIR))) == 0)
3248     {
3249       sys_close (fd);
3250       UNBLOCK_INPUT;
3251       return 0;         /* bad luck today */
3252     }
3253   UNBLOCK_INPUT;
3254
3255   dirp->dd_fd = fd;
3256   dirp->dd_loc = dirp->dd_size = 0;     /* refill needed */
3257
3258   return dirp;
3259 }
3260
3261 void
3262 closedir (dirp)
3263      register DIR *dirp;                /* stream from opendir */
3264 {
3265   sys_close (dirp->dd_fd);
3266   xfree ((char *) dirp);
3267 }
3268
3269
3270 #ifndef VMS
3271 #define DIRSIZ  14
3272 struct olddir
3273   {
3274     ino_t od_ino;               /* inode */
3275     char od_name[DIRSIZ];       /* filename */
3276   };
3277 #endif /* not VMS */
3278
3279 struct direct dir_static;       /* simulated directory contents */
3280
3281 /* ARGUSED */
3282 struct direct *
3283 readdir (dirp)
3284      register DIR *dirp;        /* stream from opendir */
3285 {
3286 #ifndef VMS
3287   register struct olddir *dp;   /* -> directory data */
3288 #else /* VMS */
3289   register struct dir$_name *dp; /* -> directory data */
3290   register struct dir$_version *dv; /* -> version data */
3291 #endif /* VMS */
3292
3293   for (; ;)
3294     {
3295       if (dirp->dd_loc >= dirp->dd_size)
3296         dirp->dd_loc = dirp->dd_size = 0;
3297
3298       if (dirp->dd_size == 0    /* refill buffer */
3299           && (dirp->dd_size = sys_read (dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ)) <= 0)
3300         return 0;
3301
3302 #ifndef VMS
3303       dp = (struct olddir *) &dirp->dd_buf[dirp->dd_loc];
3304       dirp->dd_loc += sizeof (struct olddir);
3305
3306       if (dp->od_ino != 0)      /* not deleted entry */
3307         {
3308           dir_static.d_ino = dp->od_ino;
3309           strncpy (dir_static.d_name, dp->od_name, DIRSIZ);
3310           dir_static.d_name[DIRSIZ] = '\0';
3311           dir_static.d_namlen = strlen (dir_static.d_name);
3312           dir_static.d_reclen = sizeof (struct direct)
3313             - MAXNAMLEN + 3
3314               + dir_static.d_namlen - dir_static.d_namlen % 4;
3315           return &dir_static;   /* -> simulated structure */
3316         }
3317 #else /* VMS */
3318       dp = (struct dir$_name *) dirp->dd_buf;
3319       if (dirp->dd_loc == 0)
3320         dirp->dd_loc = (dp->dir$b_namecount&1) ? dp->dir$b_namecount + 1
3321           : dp->dir$b_namecount;
3322       dv = (struct dir$_version *)&dp->dir$t_name[dirp->dd_loc];
3323       dir_static.d_ino = dv->dir$w_fid_num;
3324       dir_static.d_namlen = dp->dir$b_namecount;
3325       dir_static.d_reclen = sizeof (struct direct)
3326         - MAXNAMLEN + 3
3327           + dir_static.d_namlen - dir_static.d_namlen % 4;
3328       strncpy (dir_static.d_name, dp->dir$t_name, dp->dir$b_namecount);
3329       dir_static.d_name[dir_static.d_namlen] = '\0';
3330       dirp->dd_loc = dirp->dd_size; /* only one record at a time */
3331       return &dir_static;
3332 #endif /* VMS */
3333     }
3334 }
3335
3336 #ifdef VMS
3337 /* readdirver is just like readdir except it returns all versions of a file
3338    as separate entries.  */
3339
3340 /* ARGUSED */
3341 struct direct *
3342 readdirver (dirp)
3343      register DIR *dirp;        /* stream from opendir */
3344 {
3345   register struct dir$_name *dp; /* -> directory data */
3346   register struct dir$_version *dv; /* -> version data */
3347
3348   if (dirp->dd_loc >= dirp->dd_size - sizeof (struct dir$_name))
3349     dirp->dd_loc = dirp->dd_size = 0;
3350
3351   if (dirp->dd_size == 0        /* refill buffer */
3352       && (dirp->dd_size = sys_read (dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ)) <= 0)
3353     return 0;
3354
3355   dp = (struct dir$_name *) dirp->dd_buf;
3356   if (dirp->dd_loc == 0)
3357     dirp->dd_loc = (dp->dir$b_namecount & 1) ? dp->dir$b_namecount + 1
3358                    : dp->dir$b_namecount;
3359   dv = (struct dir$_version *) &dp->dir$t_name[dirp->dd_loc];
3360   strncpy (dir_static.d_name, dp->dir$t_name, dp->dir$b_namecount);
3361   sprintf (&dir_static.d_name[dp->dir$b_namecount], ";%d", dv->dir$w_version);
3362   dir_static.d_namlen = strlen (dir_static.d_name);
3363   dir_static.d_ino = dv->dir$w_fid_num;
3364   dir_static.d_reclen = sizeof (struct direct) - MAXNAMLEN + 3
3365                         + dir_static.d_namlen - dir_static.d_namlen % 4;
3366   dirp->dd_loc = ((char *) (++dv) - dp->dir$t_name);
3367   return &dir_static;
3368 }
3369
3370 #endif /* VMS */
3371
3372 #endif /* NONSYSTEM_DIR_LIBRARY */
3373
3374 \f
3375 /* mkdir and rmdir functions, for systems which don't have them.  */
3376
3377 #ifndef HAVE_MKDIR
3378 /*
3379  * Written by Robert Rother, Mariah Corporation, August 1985.
3380  *
3381  * If you want it, it's yours.  All I ask in return is that if you
3382  * figure out how to do this in a Bourne Shell script you send me
3383  * a copy.
3384  *                                      sdcsvax!rmr or rmr@uscd
3385  *
3386  * Severely hacked over by John Gilmore to make a 4.2BSD compatible
3387  * subroutine.  11Mar86; hoptoad!gnu
3388  *
3389  * Modified by rmtodd@uokmax 6-28-87 -- when making an already existing dir,
3390  * subroutine didn't return EEXIST.  It does now.
3391  */
3392
3393 /*
3394  * Make a directory.
3395  */
3396 #ifdef MKDIR_PROTOTYPE
3397 MKDIR_PROTOTYPE
3398 #else
3399 int
3400 mkdir (dpath, dmode)
3401      char *dpath;
3402      int dmode;
3403 #endif
3404 {
3405   int cpid, status, fd;
3406   struct stat statbuf;
3407
3408   if (stat (dpath, &statbuf) == 0)
3409     {
3410       errno = EEXIST;           /* Stat worked, so it already exists */
3411       return -1;
3412     }
3413
3414   /* If stat fails for a reason other than non-existence, return error */
3415   if (errno != ENOENT)
3416     return -1;
3417
3418   synch_process_alive = 1;
3419   switch (cpid = fork ())
3420     {
3421
3422     case -1:                    /* Error in fork */
3423       return (-1);              /* Errno is set already */
3424
3425     case 0:                     /* Child process */
3426       /*
3427                  * Cheap hack to set mode of new directory.  Since this
3428                  * child process is going away anyway, we zap its umask.
3429                  * FIXME, this won't suffice to set SUID, SGID, etc. on this
3430                  * directory.  Does anybody care?
3431                  */
3432       status = umask (0);       /* Get current umask */
3433       status = umask (status | (0777 & ~dmode));        /* Set for mkdir */
3434       fd = sys_open("/dev/null", 2);
3435       if (fd >= 0)
3436         {
3437           dup2 (fd, 0);
3438           dup2 (fd, 1);
3439           dup2 (fd, 2);
3440         }
3441       execl ("/bin/mkdir", "mkdir", dpath, (char *) 0);
3442       _exit (-1);               /* Can't exec /bin/mkdir */
3443
3444     default:                    /* Parent process */
3445       wait_for_termination (cpid);
3446     }
3447
3448   if (synch_process_death != 0 || synch_process_retcode != 0)
3449     {
3450       errno = EIO;              /* We don't know why, but */
3451       return -1;                /* /bin/mkdir failed */
3452     }
3453
3454   return 0;
3455 }
3456 #endif /* not HAVE_MKDIR */
3457
3458 #ifndef HAVE_RMDIR
3459 int
3460 rmdir (dpath)
3461      char *dpath;
3462 {
3463   int cpid, status, fd;
3464   struct stat statbuf;
3465
3466   if (stat (dpath, &statbuf) != 0)
3467     {
3468       /* Stat just set errno.  We don't have to */
3469       return -1;
3470     }
3471
3472   synch_process_alive = 1;
3473   switch (cpid = fork ())
3474     {
3475
3476     case -1:                    /* Error in fork */
3477       return (-1);              /* Errno is set already */
3478
3479     case 0:                     /* Child process */
3480       fd = sys_open("/dev/null", 2);
3481       if (fd >= 0)
3482         {
3483           dup2 (fd, 0);
3484           dup2 (fd, 1);
3485           dup2 (fd, 2);
3486         }
3487       wait_for_termination (cpid);
3488   if (synch_process_death != 0 || synch_process_retcode != 0)
3489       return -1;                /* /bin/rmdir failed */
3490     default:                    /* Parent process */
3491       while (cpid != wait (&status));   /* Wait for kid to finish */
3492     }
3493
3494   if (WIFSIGNALED (status) || WEXITSTATUS (status) != 0)
3495     {
3496       errno = EIO;              /* We don't know why, but */
3497       return -1;                /* /bin/mkdir failed */
3498     }
3499
3500   return 0;
3501 }
3502 #endif /* !HAVE_RMDIR */
3503
3504
3505 \f
3506 /* Functions for VMS */
3507 #ifdef VMS
3508 #include "vms-pwd.h"
3509 #include <acldef.h>
3510 #include <chpdef.h>
3511 #include <jpidef.h>
3512
3513 /* Return as a string the VMS error string pertaining to STATUS.
3514    Reuses the same static buffer each time it is called.  */
3515
3516 char *
3517 vmserrstr (status)
3518      int status;                /* VMS status code */
3519 {
3520   int bufadr[2];
3521   short len;
3522   static char buf[257];
3523
3524   bufadr[0] = sizeof buf - 1;
3525   bufadr[1] = (int) buf;
3526   if (! (SYS$GETMSG (status, &len, bufadr, 0x1, 0) & 1))
3527     return "untranslatable VMS error status";
3528   buf[len] = '\0';
3529   return buf;
3530 }
3531
3532 #ifdef access
3533 #undef access
3534
3535 /* The following is necessary because 'access' emulation by VMS C (2.0) does
3536  * not work correctly.  (It also doesn't work well in version 2.3.)
3537  */
3538
3539 #ifdef VMS4_4
3540
3541 #define DESCRIPTOR(name,string) struct dsc$descriptor_s name = \
3542         { strlen (string), DSC$K_DTYPE_T, DSC$K_CLASS_S, string }
3543
3544 typedef union {
3545     struct {
3546         unsigned short s_buflen;
3547         unsigned short s_code;
3548         char *s_bufadr;
3549         unsigned short *s_retlenadr;
3550     } s;
3551     int end;
3552 } item;
3553 #define buflen s.s_buflen
3554 #define code s.s_code
3555 #define bufadr s.s_bufadr
3556 #define retlenadr s.s_retlenadr
3557
3558 #define R_OK 4  /* test for read permission */
3559 #define W_OK 2  /* test for write permission */
3560 #define X_OK 1  /* test for execute (search) permission */
3561 #define F_OK 0  /* test for presence of file */
3562
3563 int
3564 sys_access (path, mode)
3565      char *path;
3566      int mode;
3567 {
3568   static char *user = NULL;
3569   char dir_fn[512];
3570
3571   /* translate possible directory spec into .DIR file name, so brain-dead
3572    * access can treat the directory like a file.  */
3573   if (directory_file_name (path, dir_fn))
3574     path = dir_fn;
3575
3576   if (mode == F_OK)
3577     return access (path, mode);
3578   if (user == NULL && (user = (char *) getenv ("USER")) == NULL)
3579     return -1;
3580   {
3581     int stat;
3582     int flags;
3583     int acces;
3584     unsigned short int dummy;
3585     item itemlst[3];
3586     static int constant = ACL$C_FILE;
3587     DESCRIPTOR (path_desc, path);
3588     DESCRIPTOR (user_desc, user);
3589
3590     flags = 0;
3591     acces = 0;
3592     if ((mode & X_OK) && ((stat = access (path, mode)) < 0 || mode == X_OK))
3593       return stat;
3594     if (mode & R_OK)
3595       acces |= CHP$M_READ;
3596     if (mode & W_OK)
3597       acces |= CHP$M_WRITE;
3598     itemlst[0].buflen = sizeof (int);
3599     itemlst[0].code = CHP$_FLAGS;
3600     itemlst[0].bufadr = (char *) &flags;
3601     itemlst[0].retlenadr = &dummy;
3602     itemlst[1].buflen = sizeof (int);
3603     itemlst[1].code = CHP$_ACCESS;
3604     itemlst[1].bufadr = (char *) &acces;
3605     itemlst[1].retlenadr = &dummy;
3606     itemlst[2].end = CHP$_END;
3607     stat = SYS$CHECK_ACCESS (&constant, &path_desc, &user_desc, itemlst);
3608     return stat == SS$_NORMAL ? 0 : -1;
3609   }
3610 }
3611
3612 #else /* not VMS4_4 */
3613
3614 #include <prvdef.h>
3615 #define ACE$M_WRITE     2
3616 #define ACE$C_KEYID     1
3617
3618 static unsigned short memid, grpid;
3619 static unsigned int uic;
3620
3621 /* Called from init_sys_modes, so it happens not very often
3622    but at least each time Emacs is loaded.  */
3623 sys_access_reinit ()
3624 {
3625   uic = 0;
3626 }
3627
3628 int
3629 sys_access (filename, type)
3630      char * filename;
3631      int type;
3632 {
3633   struct FAB fab;
3634   struct XABPRO xab;
3635   int status, size, i, typecode, acl_controlled;
3636   unsigned int *aclptr, *aclend, aclbuf[60];
3637   union prvdef prvmask;
3638
3639   /* Get UIC and GRP values for protection checking.  */
3640   if (uic == 0)
3641     {
3642       status = LIB$GETJPI (&JPI$_UIC, 0, 0, &uic, 0, 0);
3643       if (! (status & 1))
3644         return -1;
3645       memid = uic & 0xFFFF;
3646       grpid = uic >> 16;
3647     }
3648
3649   if (type != 2)                /* not checking write access */
3650     return access (filename, type);
3651
3652   /* Check write protection. */
3653
3654 #define CHECKPRIV(bit)    (prvmask.bit)
3655 #define WRITEABLE(field)  (! ((xab.xab$w_pro >> field) & XAB$M_NOWRITE))
3656
3657   /* Find privilege bits */
3658   status = SYS$SETPRV (0, 0, 0, prvmask);
3659   if (! (status & 1))
3660     error ("Unable to find privileges: %s", vmserrstr (status));
3661   if (CHECKPRIV (PRV$V_BYPASS))
3662     return 0;                   /* BYPASS enabled */
3663   fab = cc$rms_fab;
3664   fab.fab$b_fac = FAB$M_GET;
3665   fab.fab$l_fna = filename;
3666   fab.fab$b_fns = strlen (filename);
3667   fab.fab$l_xab = &xab;
3668   xab = cc$rms_xabpro;
3669   xab.xab$l_aclbuf = aclbuf;
3670   xab.xab$w_aclsiz = sizeof (aclbuf);
3671   status = SYS$OPEN (&fab, 0, 0);
3672   if (! (status & 1))
3673     return -1;
3674   SYS$CLOSE (&fab, 0, 0);
3675   /* Check system access */
3676   if (CHECKPRIV (PRV$V_SYSPRV) && WRITEABLE (XAB$V_SYS))
3677     return 0;
3678   /* Check ACL entries, if any */
3679   acl_controlled = 0;
3680   if (xab.xab$w_acllen > 0)
3681     {
3682       aclptr = aclbuf;
3683       aclend = &aclbuf[xab.xab$w_acllen / 4];
3684       while (*aclptr && aclptr < aclend)
3685         {
3686           size = (*aclptr & 0xff) / 4;
3687           typecode = (*aclptr >> 8) & 0xff;
3688           if (typecode == ACE$C_KEYID)
3689             for (i = size - 1; i > 1; i--)
3690               if (aclptr[i] == uic)
3691                 {
3692                   acl_controlled = 1;
3693                   if (aclptr[1] & ACE$M_WRITE)
3694                     return 0;   /* Write access through ACL */
3695                 }
3696           aclptr = &aclptr[size];
3697         }
3698       if (acl_controlled)       /* ACL specified, prohibits write access */
3699         return -1;
3700     }
3701   /* No ACL entries specified, check normal protection */
3702   if (WRITEABLE (XAB$V_WLD))    /* World writeable */
3703     return 0;
3704   if (WRITEABLE (XAB$V_GRP) &&
3705       (unsigned short) (xab.xab$l_uic >> 16) == grpid)
3706     return 0;                   /* Group writeable */
3707   if (WRITEABLE (XAB$V_OWN) &&
3708       (xab.xab$l_uic & 0xFFFF) == memid)
3709     return 0;                   /* Owner writeable */
3710
3711   return -1;    /* Not writeable */
3712 }
3713 #endif /* not VMS4_4 */
3714 #endif /* access */
3715
3716 static char vtbuf[NAM$C_MAXRSS+1];
3717
3718 /* translate a vms file spec to a unix path */
3719 char *
3720 sys_translate_vms (vfile)
3721      char * vfile;
3722 {
3723   char * p;
3724   char * targ;
3725
3726   if (!vfile)
3727     return 0;
3728
3729   targ = vtbuf;
3730
3731   /* leading device or logical name is a root directory */
3732   if (p = strchr (vfile, ':'))
3733     {
3734       *targ++ = '/';
3735       while (vfile < p)
3736         *targ++ = *vfile++;
3737       vfile++;
3738       *targ++ = '/';
3739     }
3740   p = vfile;
3741   if (*p == '[' || *p == '<')
3742     {
3743       while (*++vfile != *p + 2)
3744         switch (*vfile)
3745           {
3746           case '.':
3747             if (vfile[-1] == *p)
3748               *targ++ = '.';
3749             *targ++ = '/';
3750             break;
3751
3752           case '-':
3753             *targ++ = '.';
3754             *targ++ = '.';
3755             break;
3756
3757           default:
3758             *targ++ = *vfile;
3759             break;
3760           }
3761       vfile++;
3762       *targ++ = '/';
3763     }
3764   while (*vfile)
3765     *targ++ = *vfile++;
3766
3767   return vtbuf;
3768 }
3769
3770 static char utbuf[NAM$C_MAXRSS+1];
3771
3772 /* translate a unix path to a VMS file spec */
3773 char *
3774 sys_translate_unix (ufile)
3775      char * ufile;
3776 {
3777   int slash_seen = 0;
3778   char *p;
3779   char * targ;
3780
3781   if (!ufile)
3782     return 0;
3783
3784   targ = utbuf;
3785
3786   if (*ufile == '/')
3787     {
3788       ufile++;
3789     }
3790
3791   while (*ufile)
3792     {
3793       switch (*ufile)
3794         {
3795         case '/':
3796           if (slash_seen)
3797             if (index (&ufile[1], '/'))
3798               *targ++ = '.';
3799             else
3800               *targ++ = ']';
3801           else
3802             {
3803               *targ++ = ':';
3804               if (index (&ufile[1], '/'))
3805                 *targ++ = '[';
3806               slash_seen = 1;
3807             }
3808           break;
3809
3810         case '.':
3811           if (strncmp (ufile, "./", 2) == 0)
3812             {
3813               if (!slash_seen)
3814                 {
3815                   *targ++ = '[';
3816                   slash_seen = 1;
3817                 }
3818               ufile++;          /* skip the dot */
3819               if (index (&ufile[1], '/'))
3820                 *targ++ = '.';
3821               else
3822                 *targ++ = ']';
3823             }
3824           else if (strncmp (ufile, "../", 3) == 0)
3825             {
3826               if (!slash_seen)
3827                 {
3828                   *targ++ = '[';
3829                   slash_seen = 1;
3830                 }
3831               *targ++ = '-';
3832               ufile += 2;       /* skip the dots */
3833               if (index (&ufile[1], '/'))
3834                 *targ++ = '.';
3835               else
3836                 *targ++ = ']';
3837             }
3838           else
3839             *targ++ = *ufile;
3840           break;
3841
3842         default:
3843           *targ++ = *ufile;
3844           break;
3845         }
3846       ufile++;
3847     }
3848   *targ = '\0';
3849
3850   return utbuf;
3851 }
3852
3853 char *
3854 getwd (pathname)
3855      char *pathname;
3856 {
3857   char *ptr, *val;
3858   extern char *getcwd ();
3859
3860 #define MAXPATHLEN 1024
3861
3862   ptr = xmalloc (MAXPATHLEN);
3863   val = getcwd (ptr, MAXPATHLEN);
3864   if (val == 0)
3865     {
3866       xfree (ptr);
3867       return val;
3868     }
3869   strcpy (pathname, ptr);
3870   xfree (ptr);
3871
3872  return pathname;
3873 }
3874
3875 getppid ()
3876 {
3877   long item_code = JPI$_OWNER;
3878   unsigned long parent_id;
3879   int status;
3880
3881   if (((status = LIB$GETJPI (&item_code, 0, 0, &parent_id)) & 1) == 0)
3882     {
3883       errno = EVMSERR;
3884       vaxc$errno = status;
3885       return -1;
3886     }
3887   return parent_id;
3888 }
3889
3890 #undef getuid
3891 unsigned
3892 sys_getuid ()
3893 {
3894   return (getgid () << 16) | getuid ();
3895 }
3896
3897 int
3898 sys_read (fildes, buf, nbyte)
3899      int fildes;
3900      char *buf;
3901      unsigned int nbyte;
3902 {
3903   return read (fildes, buf, (nbyte < MAXIOSIZE ? nbyte : MAXIOSIZE));
3904 }
3905
3906 #if 0
3907 int
3908 sys_write (fildes, buf, nbyte)
3909      int fildes;
3910      char *buf;
3911      unsigned int nbyte;
3912 {
3913   register int nwrote, rtnval = 0;
3914
3915   while (nbyte > MAXIOSIZE && (nwrote = write (fildes, buf, MAXIOSIZE)) > 0) {
3916     nbyte -= nwrote;
3917     buf += nwrote;
3918     rtnval += nwrote;
3919   }
3920   if (nwrote < 0)
3921     return rtnval ? rtnval : -1;
3922   if ((nwrote = write (fildes, buf, nbyte)) < 0)
3923     return rtnval ? rtnval : -1;
3924   return (rtnval + nwrote);
3925 }
3926 #endif /* 0 */
3927
3928 /*
3929  *      VAX/VMS VAX C RTL really loses. It insists that records
3930  *      end with a newline (carriage return) character, and if they
3931  *      don't it adds one (nice of it isn't it!)
3932  *
3933  *      Thus we do this stupidity below.
3934  */
3935
3936 int
3937 sys_write (fildes, buf, nbytes)
3938      int fildes;
3939      char *buf;
3940      unsigned int nbytes;
3941 {
3942   register char *p;
3943   register char *e;
3944   int sum = 0;
3945   struct stat st;
3946
3947   fstat (fildes, &st);
3948   p = buf;
3949   while (nbytes > 0)
3950     {
3951       int len, retval;
3952
3953       /* Handle fixed-length files with carriage control.  */
3954       if (st.st_fab_rfm == FAB$C_FIX
3955           && ((st.st_fab_rat & (FAB$M_FTN | FAB$M_CR)) != 0))
3956         {
3957           len = st.st_fab_mrs;
3958           retval = write (fildes, p, min (len, nbytes));
3959           if (retval != len)
3960             return -1;
3961           retval++;     /* This skips the implied carriage control */
3962         }
3963       else
3964         {
3965           e =  p + min (MAXIOSIZE, nbytes) - 1;
3966           while (*e != '\n' && e > p) e--;
3967           if (p == e)           /* Ok.. so here we add a newline... sigh. */
3968             e = p + min (MAXIOSIZE, nbytes) - 1;
3969           len = e + 1 - p;
3970           retval = write (fildes, p, len);
3971           if (retval != len)
3972             return -1;
3973         }
3974       p += retval;
3975       sum += retval;
3976       nbytes -= retval;
3977     }
3978   return sum;
3979 }
3980
3981 /* Create file NEW copying its attributes from file OLD.  If
3982    OLD is 0 or does not exist, create based on the value of
3983    vms_stmlf_recfm. */
3984
3985 /* Protection value the file should ultimately have.
3986    Set by create_copy_attrs, and use by rename_sansversions.  */
3987 static unsigned short int fab_final_pro;
3988
3989 int
3990 creat_copy_attrs (old, new)
3991      char *old, *new;
3992 {
3993   struct FAB fab = cc$rms_fab;
3994   struct XABPRO xabpro;
3995   char aclbuf[256];     /* Choice of size is arbitrary.  See below. */
3996   extern int vms_stmlf_recfm;
3997
3998   if (old)
3999     {
4000       fab.fab$b_fac = FAB$M_GET;
4001       fab.fab$l_fna = old;
4002       fab.fab$b_fns = strlen (old);
4003       fab.fab$l_xab = (char *) &xabpro;
4004       xabpro = cc$rms_xabpro;
4005       xabpro.xab$l_aclbuf = aclbuf;
4006       xabpro.xab$w_aclsiz = sizeof aclbuf;
4007       /* Call $OPEN to fill in the fab & xabpro fields. */
4008       if (SYS$OPEN (&fab, 0, 0) & 1)
4009         {
4010           SYS$CLOSE (&fab, 0, 0);
4011           fab.fab$l_alq = 0;    /* zero the allocation quantity */
4012           if (xabpro.xab$w_acllen > 0)
4013             {
4014               if (xabpro.xab$w_acllen > sizeof aclbuf)
4015                 /* If the acl buffer was too short, redo open with longer one.
4016                    Wouldn't need to do this if there were some system imposed
4017                    limit on the size of an ACL, but I can't find any such. */
4018                 {
4019                   xabpro.xab$l_aclbuf = (char *) alloca (xabpro.xab$w_acllen);
4020                   xabpro.xab$w_aclsiz = xabpro.xab$w_acllen;
4021                   if (SYS$OPEN (&fab, 0, 0) & 1)
4022                     SYS$CLOSE (&fab, 0, 0);
4023                   else
4024                     old = 0;
4025                 }
4026             }
4027           else
4028             xabpro.xab$l_aclbuf = 0;
4029         }
4030       else
4031         old = 0;
4032     }
4033   fab.fab$l_fna = new;
4034   fab.fab$b_fns = strlen (new);
4035   if (!old)
4036     {
4037       fab.fab$l_xab = 0;
4038       fab.fab$b_rfm = vms_stmlf_recfm ? FAB$C_STMLF : FAB$C_VAR;
4039       fab.fab$b_rat = FAB$M_CR;
4040     }
4041
4042   /* Set the file protections such that we will be able to manipulate
4043      this file.  Once we are done writing and renaming it, we will set
4044      the protections back.  */
4045   if (old)
4046     fab_final_pro = xabpro.xab$w_pro;
4047   else
4048     SYS$SETDFPROT (0, &fab_final_pro);
4049   xabpro.xab$w_pro &= 0xff0f; /* set O:rewd for now. This is set back later. */
4050
4051   /* Create the new file with either default attrs or attrs copied
4052      from old file. */
4053   if (!(SYS$CREATE (&fab, 0, 0) & 1))
4054     return -1;
4055   SYS$CLOSE (&fab, 0, 0);
4056   /* As this is a "replacement" for creat, return a file descriptor
4057      opened for writing. */
4058   return open (new, O_WRONLY);
4059 }
4060
4061 #ifdef creat
4062 #undef creat
4063 #include <varargs.h>
4064 #ifdef __GNUC__
4065 #ifndef va_count
4066 #define va_count(X) ((X) = *(((int *) &(va_alist)) - 1))
4067 #endif
4068 #endif
4069
4070 sys_creat (va_alist)
4071      va_dcl
4072 {
4073   va_list list_incrementer;
4074   char *name;
4075   int mode;
4076   int rfd;                      /* related file descriptor */
4077   int fd;                       /* Our new file descriptor */
4078   int count;
4079   struct stat st_buf;
4080   char rfm[12];
4081   char rat[15];
4082   char mrs[13];
4083   char fsz[13];
4084   extern int vms_stmlf_recfm;
4085
4086   va_count (count);
4087   va_start (list_incrementer);
4088   name = va_arg (list_incrementer, char *);
4089   mode = va_arg (list_incrementer, int);
4090   if (count > 2)
4091     rfd = va_arg (list_incrementer, int);
4092   va_end (list_incrementer);
4093   if (count > 2)
4094     {
4095       /* Use information from the related file descriptor to set record
4096          format of the newly created file. */
4097       fstat (rfd, &st_buf);
4098       switch (st_buf.st_fab_rfm)
4099         {
4100         case FAB$C_FIX:
4101           strcpy (rfm, "rfm = fix");
4102           sprintf (mrs, "mrs = %d", st_buf.st_fab_mrs);
4103           strcpy (rat, "rat = ");
4104           if (st_buf.st_fab_rat & FAB$M_CR)
4105             strcat (rat, "cr");
4106           else if (st_buf.st_fab_rat & FAB$M_FTN)
4107             strcat (rat, "ftn");
4108           else if (st_buf.st_fab_rat & FAB$M_PRN)
4109             strcat (rat, "prn");
4110           if (st_buf.st_fab_rat & FAB$M_BLK)
4111             if (st_buf.st_fab_rat & (FAB$M_CR|FAB$M_FTN|FAB$M_PRN))
4112               strcat (rat, ", blk");
4113             else
4114               strcat (rat, "blk");
4115           return creat (name, 0, rfm, rat, mrs);
4116
4117         case FAB$C_VFC:
4118           strcpy (rfm, "rfm = vfc");
4119           sprintf (fsz, "fsz = %d", st_buf.st_fab_fsz);
4120           strcpy (rat, "rat = ");
4121           if (st_buf.st_fab_rat & FAB$M_CR)
4122             strcat (rat, "cr");
4123           else if (st_buf.st_fab_rat & FAB$M_FTN)
4124             strcat (rat, "ftn");
4125           else if (st_buf.st_fab_rat & FAB$M_PRN)
4126             strcat (rat, "prn");
4127           if (st_buf.st_fab_rat & FAB$M_BLK)
4128             if (st_buf.st_fab_rat & (FAB$M_CR|FAB$M_FTN|FAB$M_PRN))
4129               strcat (rat, ", blk");
4130             else
4131               strcat (rat, "blk");
4132           return creat (name, 0, rfm, rat, fsz);
4133
4134         case FAB$C_STM:
4135           strcpy (rfm, "rfm = stm");
4136           break;
4137
4138         case FAB$C_STMCR:
4139           strcpy (rfm, "rfm = stmcr");
4140           break;
4141
4142         case FAB$C_STMLF:
4143           strcpy (rfm, "rfm = stmlf");
4144           break;
4145
4146         case FAB$C_UDF:
4147           strcpy (rfm, "rfm = udf");
4148           break;
4149
4150         case FAB$C_VAR:
4151           strcpy (rfm, "rfm = var");
4152           break;
4153         }
4154       strcpy (rat, "rat = ");
4155       if (st_buf.st_fab_rat & FAB$M_CR)
4156         strcat (rat, "cr");
4157       else if (st_buf.st_fab_rat & FAB$M_FTN)
4158         strcat (rat, "ftn");
4159       else if (st_buf.st_fab_rat & FAB$M_PRN)
4160         strcat (rat, "prn");
4161       if (st_buf.st_fab_rat & FAB$M_BLK)
4162         if (st_buf.st_fab_rat & (FAB$M_CR|FAB$M_FTN|FAB$M_PRN))
4163           strcat (rat, ", blk");
4164         else
4165           strcat (rat, "blk");
4166     }
4167   else
4168     {
4169       strcpy (rfm, vms_stmlf_recfm ? "rfm = stmlf" : "rfm=var");
4170       strcpy (rat, "rat=cr");
4171     }
4172   /* Until the VAX C RTL fixes the many bugs with modes, always use
4173      mode 0 to get the user's default protection. */
4174   fd = creat (name, 0, rfm, rat);
4175   if (fd < 0 && errno == EEXIST)
4176     {
4177       if (unlink (name) < 0)
4178         report_file_error ("delete", build_string (name));
4179       fd = creat (name, 0, rfm, rat);
4180     }
4181   return fd;
4182 }
4183 #endif /* creat */
4184
4185 /* fwrite to stdout is S L O W.  Speed it up by using fputc...*/
4186 sys_fwrite (ptr, size, num, fp)
4187      register char * ptr;
4188      FILE * fp;
4189 {
4190   register int tot = num * size;
4191
4192   while (tot--)
4193     fputc (*ptr++, fp);
4194 }
4195
4196 /*
4197  * The VMS C library routine creat actually creates a new version of an
4198  * existing file rather than truncating the old version.  There are times
4199  * when this is not the desired behavior, for instance, when writing an
4200  * auto save file (you only want one version), or when you don't have
4201  * write permission in the directory containing the file (but the file
4202  * itself is writable).  Hence this routine, which is equivalent to
4203  * "close (creat (fn, 0));" on Unix if fn already exists.
4204  */
4205 int
4206 vms_truncate (fn)
4207      char *fn;
4208 {
4209   struct FAB xfab = cc$rms_fab;
4210   struct RAB xrab = cc$rms_rab;
4211   int status;
4212
4213   xfab.fab$l_fop = FAB$M_TEF;   /* free allocated but unused blocks on close */
4214   xfab.fab$b_fac = FAB$M_TRN | FAB$M_GET; /* allow truncate and get access */
4215   xfab.fab$b_shr = FAB$M_NIL;   /* allow no sharing - file must be locked */
4216   xfab.fab$l_fna = fn;
4217   xfab.fab$b_fns = strlen (fn);
4218   xfab.fab$l_dna = ";0";        /* default to latest version of the file */
4219   xfab.fab$b_dns = 2;
4220   xrab.rab$l_fab = &xfab;
4221
4222   /* This gibberish opens the file, positions to the first record, and
4223      deletes all records from there until the end of file. */
4224   if ((SYS$OPEN (&xfab) & 01) == 01)
4225     {
4226       if ((SYS$CONNECT (&xrab) & 01) == 01 &&
4227           (SYS$FIND (&xrab) & 01) == 01 &&
4228           (SYS$TRUNCATE (&xrab) & 01) == 01)
4229         status = 0;
4230       else
4231         status = -1;
4232     }
4233   else
4234     status = -1;
4235   SYS$CLOSE (&xfab);
4236   return status;
4237 }
4238
4239 /* Define this symbol to actually read SYSUAF.DAT.  This requires either
4240    SYSPRV or a readable SYSUAF.DAT. */
4241
4242 #ifdef READ_SYSUAF
4243 /*
4244  * getuaf.c
4245  *
4246  * Routine to read the VMS User Authorization File and return
4247  * a specific user's record.
4248  */
4249
4250 static struct UAF retuaf;
4251
4252 struct UAF *
4253 get_uaf_name (uname)
4254      char * uname;
4255 {
4256   register status;
4257   struct FAB uaf_fab;
4258   struct RAB uaf_rab;
4259
4260   uaf_fab = cc$rms_fab;
4261   uaf_rab = cc$rms_rab;
4262   /* initialize fab fields */
4263   uaf_fab.fab$l_fna = "SYS$SYSTEM:SYSUAF.DAT";
4264   uaf_fab.fab$b_fns = 21;
4265   uaf_fab.fab$b_fac = FAB$M_GET;
4266   uaf_fab.fab$b_org = FAB$C_IDX;
4267   uaf_fab.fab$b_shr = FAB$M_GET|FAB$M_PUT|FAB$M_UPD|FAB$M_DEL;
4268   /* initialize rab fields */
4269   uaf_rab.rab$l_fab = &uaf_fab;
4270   /* open the User Authorization File */
4271   status = SYS$OPEN (&uaf_fab);
4272   if (!(status&1))
4273     {
4274       errno = EVMSERR;
4275       vaxc$errno = status;
4276       return 0;
4277     }
4278   status = SYS$CONNECT (&uaf_rab);
4279   if (!(status&1))
4280     {
4281       errno = EVMSERR;
4282       vaxc$errno = status;
4283       return 0;
4284     }
4285   /* read the requested record - index is in uname */
4286   uaf_rab.rab$l_kbf = uname;
4287   uaf_rab.rab$b_ksz = strlen (uname);
4288   uaf_rab.rab$b_rac = RAB$C_KEY;
4289   uaf_rab.rab$l_ubf = (char *)&retuaf;
4290   uaf_rab.rab$w_usz = sizeof retuaf;
4291   status = SYS$GET (&uaf_rab);
4292   if (!(status&1))
4293     {
4294       errno = EVMSERR;
4295       vaxc$errno = status;
4296       return 0;
4297     }
4298   /* close the User Authorization File */
4299   status = SYS$DISCONNECT (&uaf_rab);
4300   if (!(status&1))
4301     {
4302       errno = EVMSERR;
4303       vaxc$errno = status;
4304       return 0;
4305     }
4306   status = SYS$CLOSE (&uaf_fab);
4307   if (!(status&1))
4308     {
4309       errno = EVMSERR;
4310       vaxc$errno = status;
4311       return 0;
4312     }
4313   return &retuaf;
4314 }
4315
4316 struct UAF *
4317 get_uaf_uic (uic)
4318      unsigned long uic;
4319 {
4320   register status;
4321   struct FAB uaf_fab;
4322   struct RAB uaf_rab;
4323
4324   uaf_fab = cc$rms_fab;
4325   uaf_rab = cc$rms_rab;
4326   /* initialize fab fields */
4327   uaf_fab.fab$l_fna = "SYS$SYSTEM:SYSUAF.DAT";
4328   uaf_fab.fab$b_fns = 21;
4329   uaf_fab.fab$b_fac = FAB$M_GET;
4330   uaf_fab.fab$b_org = FAB$C_IDX;
4331   uaf_fab.fab$b_shr = FAB$M_GET|FAB$M_PUT|FAB$M_UPD|FAB$M_DEL;
4332   /* initialize rab fields */
4333   uaf_rab.rab$l_fab = &uaf_fab;
4334   /* open the User Authorization File */
4335   status = SYS$OPEN (&uaf_fab);
4336   if (!(status&1))
4337     {
4338       errno = EVMSERR;
4339       vaxc$errno = status;
4340       return 0;
4341     }
4342   status = SYS$CONNECT (&uaf_rab);
4343   if (!(status&1))
4344     {
4345       errno = EVMSERR;
4346       vaxc$errno = status;
4347       return 0;
4348     }
4349   /* read the requested record - index is in uic */
4350   uaf_rab.rab$b_krf = 1;        /* 1st alternate key */
4351   uaf_rab.rab$l_kbf = (char *) &uic;
4352   uaf_rab.rab$b_ksz = sizeof uic;
4353   uaf_rab.rab$b_rac = RAB$C_KEY;
4354   uaf_rab.rab$l_ubf = (char *)&retuaf;
4355   uaf_rab.rab$w_usz = sizeof retuaf;
4356   status = SYS$GET (&uaf_rab);
4357   if (!(status&1))
4358     {
4359       errno = EVMSERR;
4360       vaxc$errno = status;
4361       return 0;
4362     }
4363   /* close the User Authorization File */
4364   status = SYS$DISCONNECT (&uaf_rab);
4365   if (!(status&1))
4366     {
4367       errno = EVMSERR;
4368       vaxc$errno = status;
4369       return 0;
4370     }
4371   status = SYS$CLOSE (&uaf_fab);
4372   if (!(status&1))
4373     {
4374       errno = EVMSERR;
4375       vaxc$errno = status;
4376       return 0;
4377     }
4378   return &retuaf;
4379 }
4380
4381 static struct passwd retpw;
4382
4383 struct passwd *
4384 cnv_uaf_pw (up)
4385      struct UAF * up;
4386 {
4387   char * ptr;
4388
4389   /* copy these out first because if the username is 32 chars, the next
4390      section will overwrite the first byte of the UIC */
4391   retpw.pw_uid = up->uaf$w_mem;
4392   retpw.pw_gid = up->uaf$w_grp;
4393
4394   /* I suppose this is not the best sytle, to possibly overwrite one
4395      byte beyond the end of the field, but what the heck... */
4396   ptr = &up->uaf$t_username[UAF$S_USERNAME];
4397   while (ptr[-1] == ' ')
4398     ptr--;
4399   *ptr = '\0';
4400   strcpy (retpw.pw_name, up->uaf$t_username);
4401
4402   /* the rest of these are counted ascii strings */
4403   strncpy (retpw.pw_gecos, &up->uaf$t_owner[1], up->uaf$t_owner[0]);
4404   retpw.pw_gecos[up->uaf$t_owner[0]] = '\0';
4405   strncpy (retpw.pw_dir, &up->uaf$t_defdev[1], up->uaf$t_defdev[0]);
4406   retpw.pw_dir[up->uaf$t_defdev[0]] = '\0';
4407   strncat (retpw.pw_dir, &up->uaf$t_defdir[1], up->uaf$t_defdir[0]);
4408   retpw.pw_dir[up->uaf$t_defdev[0] + up->uaf$t_defdir[0]] = '\0';
4409   strncpy (retpw.pw_shell, &up->uaf$t_defcli[1], up->uaf$t_defcli[0]);
4410   retpw.pw_shell[up->uaf$t_defcli[0]] = '\0';
4411
4412   return &retpw;
4413 }
4414 #else /* not READ_SYSUAF */
4415 static struct passwd retpw;
4416 #endif /* not READ_SYSUAF */
4417
4418 struct passwd *
4419 getpwnam (name)
4420      char * name;
4421 {
4422 #ifdef READ_SYSUAF
4423   struct UAF *up;
4424 #else
4425   char * user;
4426   char * dir;
4427   unsigned char * full;
4428 #endif /* READ_SYSUAF */
4429   char *ptr = name;
4430
4431   while (*ptr)
4432     {
4433       if ('a' <= *ptr && *ptr <= 'z')
4434         *ptr -= 040;
4435       ptr++;
4436     }
4437 #ifdef READ_SYSUAF
4438   if (!(up = get_uaf_name (name)))
4439     return 0;
4440   return cnv_uaf_pw (up);
4441 #else
4442   if (strcmp (name, getenv ("USER")) == 0)
4443     {
4444       retpw.pw_uid = getuid ();
4445       retpw.pw_gid = getgid ();
4446       strcpy (retpw.pw_name, name);
4447       if (full = egetenv ("FULLNAME"))
4448         strcpy (retpw.pw_gecos, full);
4449       else
4450         *retpw.pw_gecos = '\0';
4451       strcpy (retpw.pw_dir, egetenv ("HOME"));
4452       *retpw.pw_shell = '\0';
4453       return &retpw;
4454     }
4455   else
4456     return 0;
4457 #endif /* not READ_SYSUAF */
4458 }
4459
4460 struct passwd *
4461 getpwuid (uid)
4462      unsigned long uid;
4463 {
4464 #ifdef READ_SYSUAF
4465   struct UAF * up;
4466
4467   if (!(up = get_uaf_uic (uid)))
4468     return 0;
4469   return cnv_uaf_pw (up);
4470 #else
4471   if (uid == sys_getuid ())
4472     return getpwnam (egetenv ("USER"));
4473   else
4474     return 0;
4475 #endif /* not READ_SYSUAF */
4476 }
4477
4478 /* return total address space available to the current process.  This is
4479    the sum of the current p0 size, p1 size and free page table entries
4480    available. */
4481 vlimit ()
4482 {
4483   int item_code;
4484   unsigned long free_pages;
4485   unsigned long frep0va;
4486   unsigned long frep1va;
4487   register status;
4488
4489   item_code = JPI$_FREPTECNT;
4490   if (((status = LIB$GETJPI (&item_code, 0, 0, &free_pages)) & 1) == 0)
4491     {
4492       errno = EVMSERR;
4493       vaxc$errno = status;
4494       return -1;
4495     }
4496   free_pages *= 512;
4497
4498   item_code = JPI$_FREP0VA;
4499   if (((status = LIB$GETJPI (&item_code, 0, 0, &frep0va)) & 1) == 0)
4500     {
4501       errno = EVMSERR;
4502       vaxc$errno = status;
4503       return -1;
4504     }
4505   item_code = JPI$_FREP1VA;
4506   if (((status = LIB$GETJPI (&item_code, 0, 0, &frep1va)) & 1) == 0)
4507     {
4508       errno = EVMSERR;
4509       vaxc$errno = status;
4510       return -1;
4511     }
4512
4513   return free_pages + frep0va + (0x7fffffff - frep1va);
4514 }
4515
4516 define_logical_name (varname, string)
4517      char *varname;
4518      char *string;
4519 {
4520   struct dsc$descriptor_s strdsc =
4521     {strlen (string), DSC$K_DTYPE_T, DSC$K_CLASS_S, string};
4522   struct dsc$descriptor_s envdsc =
4523     {strlen (varname), DSC$K_DTYPE_T, DSC$K_CLASS_S, varname};
4524   struct dsc$descriptor_s lnmdsc =
4525     {7, DSC$K_DTYPE_T, DSC$K_CLASS_S, "LNM$JOB"};
4526
4527   return LIB$SET_LOGICAL (&envdsc, &strdsc, &lnmdsc, 0, 0);
4528 }
4529
4530 delete_logical_name (varname)
4531      char *varname;
4532 {
4533   struct dsc$descriptor_s envdsc =
4534     {strlen (varname), DSC$K_DTYPE_T, DSC$K_CLASS_S, varname};
4535   struct dsc$descriptor_s lnmdsc =
4536     {7, DSC$K_DTYPE_T, DSC$K_CLASS_S, "LNM$JOB"};
4537
4538   return LIB$DELETE_LOGICAL (&envdsc, &lnmdsc);
4539 }
4540
4541 ulimit ()
4542 {}
4543
4544 setpgrp ()
4545 {}
4546
4547 execvp ()
4548 {
4549   error ("execvp system call not implemented");
4550 }
4551
4552 int
4553 rename (from, to)
4554      char *from, *to;
4555 {
4556   int status;
4557   struct FAB from_fab = cc$rms_fab, to_fab = cc$rms_fab;
4558   struct NAM from_nam = cc$rms_nam, to_nam = cc$rms_nam;
4559   char from_esn[NAM$C_MAXRSS];
4560   char to_esn[NAM$C_MAXRSS];
4561
4562   from_fab.fab$l_fna = from;
4563   from_fab.fab$b_fns = strlen (from);
4564   from_fab.fab$l_nam = &from_nam;
4565   from_fab.fab$l_fop = FAB$M_NAM;
4566
4567   from_nam.nam$l_esa = from_esn;
4568   from_nam.nam$b_ess = sizeof from_esn;
4569
4570   to_fab.fab$l_fna = to;
4571   to_fab.fab$b_fns = strlen (to);
4572   to_fab.fab$l_nam = &to_nam;
4573   to_fab.fab$l_fop = FAB$M_NAM;
4574
4575   to_nam.nam$l_esa = to_esn;
4576   to_nam.nam$b_ess = sizeof to_esn;
4577
4578   status = SYS$RENAME (&from_fab, 0, 0, &to_fab);
4579
4580   if (status & 1)
4581     return 0;
4582   else
4583     {
4584       if (status == RMS$_DEV)
4585         errno = EXDEV;
4586       else
4587         errno = EVMSERR;
4588       vaxc$errno = status;
4589       return -1;
4590     }
4591 }
4592
4593 /* This function renames a file like `rename', but it strips
4594    the version number from the "to" filename, such that the "to" file is
4595    will always be a new version.  It also sets the file protection once it is
4596    finished.  The protection that we will use is stored in fab_final_pro,
4597    and was set when we did a creat_copy_attrs to create the file that we
4598    are renaming.
4599
4600    We could use the chmod function, but Eunichs uses 3 bits per user category
4601    to describe the protection, and VMS uses 4 (write and delete are separate
4602    bits).  To maintain portability, the VMS implementation of `chmod' wires
4603    the W and D bits together.  */
4604
4605
4606 static struct fibdef fib;       /* We need this initialized to zero */
4607 char vms_file_written[NAM$C_MAXRSS];
4608
4609 int
4610 rename_sans_version (from,to)
4611      char *from, *to;
4612 {
4613   short int chan;
4614   int stat;
4615   short int iosb[4];
4616   int status;
4617   struct FAB to_fab = cc$rms_fab;
4618   struct NAM to_nam = cc$rms_nam;
4619   struct dsc$descriptor fib_d ={sizeof (fib),0,0,(char*) &fib};
4620   struct dsc$descriptor fib_attr[2]
4621     = {{sizeof (fab_final_pro),ATR$C_FPRO,0,(char*) &fab_final_pro},{0,0,0,0}};
4622   char to_esn[NAM$C_MAXRSS];
4623
4624   $DESCRIPTOR (disk,to_esn);
4625
4626   to_fab.fab$l_fna = to;
4627   to_fab.fab$b_fns = strlen (to);
4628   to_fab.fab$l_nam = &to_nam;
4629   to_fab.fab$l_fop = FAB$M_NAM;
4630
4631   to_nam.nam$l_esa = to_esn;
4632   to_nam.nam$b_ess = sizeof to_esn;
4633
4634   status = SYS$PARSE (&to_fab, 0, 0); /* figure out the full file name */
4635
4636   if (to_nam.nam$l_fnb && NAM$M_EXP_VER)
4637     *(to_nam.nam$l_ver) = '\0';
4638
4639   stat = rename (from, to_esn);
4640   if (stat < 0)
4641     return stat;
4642
4643   strcpy (vms_file_written, to_esn);
4644
4645   to_fab.fab$l_fna = vms_file_written; /* this points to the versionless name */
4646   to_fab.fab$b_fns = strlen (vms_file_written);
4647
4648   /* Now set the file protection to the correct value */
4649   SYS$OPEN (&to_fab, 0, 0);     /* This fills in the nam$w_fid fields */
4650
4651   /* Copy these fields into the fib */
4652   fib.fib$r_fid_overlay.fib$w_fid[0] = to_nam.nam$w_fid[0];
4653   fib.fib$r_fid_overlay.fib$w_fid[1] = to_nam.nam$w_fid[1];
4654   fib.fib$r_fid_overlay.fib$w_fid[2] = to_nam.nam$w_fid[2];
4655
4656   SYS$CLOSE (&to_fab, 0, 0);
4657
4658   stat = SYS$ASSIGN (&disk, &chan, 0, 0); /* open a channel to the disk */
4659   if (!stat)
4660     LIB$SIGNAL (stat);
4661   stat = SYS$QIOW (0, chan, IO$_MODIFY, iosb, 0, 0, &fib_d,
4662                    0, 0, 0, &fib_attr, 0);
4663   if (!stat)
4664     LIB$SIGNAL (stat);
4665   stat = SYS$DASSGN (chan);
4666   if (!stat)
4667     LIB$SIGNAL (stat);
4668   strcpy (vms_file_written, to_esn); /* We will write this to the terminal*/
4669   return 0;
4670 }
4671
4672 link (file, new)
4673      char * file, * new;
4674 {
4675   register status;
4676   struct FAB fab;
4677   struct NAM nam;
4678   unsigned short fid[3];
4679   char esa[NAM$C_MAXRSS];
4680
4681   fab = cc$rms_fab;
4682   fab.fab$l_fop = FAB$M_OFP;
4683   fab.fab$l_fna = file;
4684   fab.fab$b_fns = strlen (file);
4685   fab.fab$l_nam = &nam;
4686
4687   nam = cc$rms_nam;
4688   nam.nam$l_esa = esa;
4689   nam.nam$b_ess = NAM$C_MAXRSS;
4690
4691   status = SYS$PARSE (&fab);
4692   if ((status & 1) == 0)
4693     {
4694       errno = EVMSERR;
4695       vaxc$errno = status;
4696       return -1;
4697     }
4698   status = SYS$SEARCH (&fab);
4699   if ((status & 1) == 0)
4700     {
4701       errno = EVMSERR;
4702       vaxc$errno = status;
4703       return -1;
4704     }
4705
4706   fid[0] = nam.nam$w_fid[0];
4707   fid[1] = nam.nam$w_fid[1];
4708   fid[2] = nam.nam$w_fid[2];
4709
4710   fab.fab$l_fna = new;
4711   fab.fab$b_fns = strlen (new);
4712
4713   status = SYS$PARSE (&fab);
4714   if ((status & 1) == 0)
4715     {
4716       errno = EVMSERR;
4717       vaxc$errno = status;
4718       return -1;
4719     }
4720
4721   nam.nam$w_fid[0] = fid[0];
4722   nam.nam$w_fid[1] = fid[1];
4723   nam.nam$w_fid[2] = fid[2];
4724
4725   nam.nam$l_esa = nam.nam$l_name;
4726   nam.nam$b_esl = nam.nam$b_name + nam.nam$b_type + nam.nam$b_ver;
4727
4728   status = SYS$ENTER (&fab);
4729   if ((status & 1) == 0)
4730     {
4731       errno = EVMSERR;
4732       vaxc$errno = status;
4733       return -1;
4734     }
4735
4736   return 0;
4737 }
4738
4739 croak (badfunc)
4740      char *badfunc;
4741 {
4742   printf ("%s not yet implemented\r\n", badfunc);
4743   reset_sys_modes ();
4744   exit (1);
4745 }
4746
4747 long
4748 random ()
4749 {
4750   /* Arrange to return a range centered on zero.  */
4751   return rand () - (1 << 30);
4752 }
4753
4754 srandom (seed)
4755 {
4756   srand (seed);
4757 }
4758 #endif /* VMS */
4759 \f
4760 #ifdef AIX
4761
4762 /* Called from init_sys_modes.  */
4763 hft_init ()
4764 {
4765   int junk;
4766
4767   /* If we're not on an HFT we shouldn't do any of this.  We determine
4768      if we are on an HFT by trying to get an HFT error code.  If this
4769      call fails, we're not on an HFT. */
4770 #ifdef IBMR2AIX
4771   if (ioctl (0, HFQERROR, &junk) < 0)
4772     return;
4773 #else /* not IBMR2AIX */
4774   if (ioctl (0, HFQEIO, 0) < 0)
4775     return;
4776 #endif /* not IBMR2AIX */
4777
4778   /* On AIX the default hft keyboard mapping uses backspace rather than delete
4779      as the rubout key's ASCII code.  Here this is changed.  The bug is that
4780      there's no way to determine the old mapping, so in reset_sys_modes
4781      we need to assume that the normal map had been present.  Of course, this
4782      code also doesn't help if on a terminal emulator which doesn't understand
4783      HFT VTD's. */
4784   {
4785     struct hfbuf buf;
4786     struct hfkeymap keymap;
4787
4788     buf.hf_bufp = (char *)&keymap;
4789     buf.hf_buflen = sizeof (keymap);
4790     keymap.hf_nkeys = 2;
4791     keymap.hfkey[0].hf_kpos = 15;
4792     keymap.hfkey[0].hf_kstate = HFMAPCHAR | HFSHFNONE;
4793 #ifdef IBMR2AIX
4794     keymap.hfkey[0].hf_keyidh = '<';
4795 #else /* not IBMR2AIX */
4796     keymap.hfkey[0].hf_page = '<';
4797 #endif /* not IBMR2AIX */
4798     keymap.hfkey[0].hf_char = 127;
4799     keymap.hfkey[1].hf_kpos = 15;
4800     keymap.hfkey[1].hf_kstate = HFMAPCHAR | HFSHFSHFT;
4801 #ifdef IBMR2AIX
4802     keymap.hfkey[1].hf_keyidh = '<';
4803 #else /* not IBMR2AIX */
4804     keymap.hfkey[1].hf_page = '<';
4805 #endif /* not IBMR2AIX */
4806     keymap.hfkey[1].hf_char = 127;
4807     hftctl (0, HFSKBD, &buf);
4808   }
4809   /* The HFT system on AIX doesn't optimize for scrolling, so it's really ugly
4810      at times.  */
4811   line_ins_del_ok = char_ins_del_ok = 0;
4812 }
4813
4814 /* Reset the rubout key to backspace. */
4815
4816 hft_reset ()
4817 {
4818   struct hfbuf buf;
4819   struct hfkeymap keymap;
4820   int junk;
4821
4822 #ifdef IBMR2AIX
4823   if (ioctl (0, HFQERROR, &junk) < 0)
4824     return;
4825 #else /* not IBMR2AIX */
4826   if (ioctl (0, HFQEIO, 0) < 0)
4827     return;
4828 #endif /* not IBMR2AIX */
4829
4830   buf.hf_bufp = (char *)&keymap;
4831   buf.hf_buflen = sizeof (keymap);
4832   keymap.hf_nkeys = 2;
4833   keymap.hfkey[0].hf_kpos = 15;
4834   keymap.hfkey[0].hf_kstate = HFMAPCHAR | HFSHFNONE;
4835 #ifdef IBMR2AIX
4836   keymap.hfkey[0].hf_keyidh = '<';
4837 #else /* not IBMR2AIX */
4838   keymap.hfkey[0].hf_page = '<';
4839 #endif /* not IBMR2AIX */
4840   keymap.hfkey[0].hf_char = 8;
4841   keymap.hfkey[1].hf_kpos = 15;
4842   keymap.hfkey[1].hf_kstate = HFMAPCHAR | HFSHFSHFT;
4843 #ifdef IBMR2AIX
4844   keymap.hfkey[1].hf_keyidh = '<';
4845 #else /* not IBMR2AIX */
4846   keymap.hfkey[1].hf_page = '<';
4847 #endif /* not IBMR2AIX */
4848   keymap.hfkey[1].hf_char = 8;
4849   hftctl (0, HFSKBD, &buf);
4850 }
4851
4852 #endif /* AIX */