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
1375 /* Get terminal size from system.
1376    Store number of lines into *heightp and width into *widthp.
1377    If zero or a negative number is stored, the value is not valid.  */
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 \f
1435 /* Prepare the terminal for exiting Emacs; move the cursor to the
1436    bottom of the frame, turn off interrupt-driven I/O, etc.  */
1437 reset_sys_modes ()
1438 {
1439   if (noninteractive)
1440     {
1441       fflush (stdout);
1442       return;
1443     }
1444   if (!term_initted)
1445     return;
1446   if (read_socket_hook || !EQ (Vwindow_system, Qnil))
1447     return;
1448   cursor_to (FRAME_HEIGHT (selected_frame) - 1, 0);
1449   clear_end_of_line (FRAME_WIDTH (selected_frame));
1450   /* clear_end_of_line may move the cursor */
1451   cursor_to (FRAME_HEIGHT (selected_frame) - 1, 0);
1452 #ifdef IBMR2AIX
1453   {
1454     /* HFT devices normally use ^J as a LF/CR.  We forced it to
1455        do the LF only.  Now, we need to reset it. */
1456     struct termio tty;
1457
1458     if (ioctl (1, HFTGETID, &tty) != -1)
1459       write (1, "\033[20h", 5);
1460   }
1461 #endif
1462
1463   reset_terminal_modes ();
1464   fflush (stdout);
1465 #ifdef BSD
1466 #ifndef BSD4_1
1467   /* Avoid possible loss of output when changing terminal modes.  */
1468   fsync (fileno (stdout));
1469 #endif
1470 #endif
1471
1472 #ifdef F_SETFL
1473 #ifndef F_SETOWN_BUG
1474 #ifdef F_SETOWN         /* F_SETFL does not imply existence of F_SETOWN */
1475   if (interrupt_input)
1476     {
1477       reset_sigio ();
1478       fcntl (input_fd, F_SETOWN, old_fcntl_owner);
1479     }
1480 #endif /* F_SETOWN */
1481 #endif /* F_SETOWN_BUG */
1482 #ifdef O_NDELAY
1483   fcntl (input_fd, F_SETFL, fcntl (input_fd, F_GETFL, 0) & ~O_NDELAY);
1484 #endif
1485 #endif /* F_SETFL */
1486 #ifdef BSD4_1
1487   if (interrupt_input)
1488     reset_sigio ();
1489 #endif /* BSD4_1 */
1490
1491   while (EMACS_SET_TTY (input_fd, &old_tty, 0) < 0 && errno == EINTR)
1492     ;
1493
1494 #ifdef MSDOS    /* Demacs 1.1.2 91/10/20 Manabu Higashida */
1495   dos_ttcooked ();
1496 #endif
1497
1498 #ifdef AIX
1499   hft_reset ();
1500 #endif
1501
1502 #ifdef BSD_PGRPS
1503   widen_foreground_group ();
1504 #endif
1505 }
1506 \f
1507 #ifdef HAVE_PTYS
1508
1509 /* Set up the proper status flags for use of a pty.  */
1510
1511 setup_pty (fd)
1512      int fd;
1513 {
1514   /* I'm told that TOICREMOTE does not mean control chars
1515      "can't be sent" but rather that they don't have
1516      input-editing or signaling effects.
1517      That should be good, because we have other ways
1518      to do those things in Emacs.
1519      However, telnet mode seems not to work on 4.2.
1520      So TIOCREMOTE is turned off now. */
1521
1522   /* Under hp-ux, if TIOCREMOTE is turned on, some calls
1523      will hang.  In particular, the "timeout" feature (which
1524      causes a read to return if there is no data available)
1525      does this.  Also it is known that telnet mode will hang
1526      in such a way that Emacs must be stopped (perhaps this
1527      is the same problem).
1528
1529      If TIOCREMOTE is turned off, then there is a bug in
1530      hp-ux which sometimes loses data.  Apparently the
1531      code which blocks the master process when the internal
1532      buffer fills up does not work.  Other than this,
1533      though, everything else seems to work fine.
1534
1535      Since the latter lossage is more benign, we may as well
1536      lose that way.  -- cph */
1537 #ifdef FIONBIO
1538 #ifdef SYSV_PTYS
1539   {
1540     int on = 1;
1541     ioctl (fd, FIONBIO, &on);
1542   }
1543 #endif
1544 #endif
1545 #ifdef IBMRTAIX
1546   /* On AIX, the parent gets SIGHUP when a pty attached child dies.  So, we */
1547   /* ignore SIGHUP once we've started a child on a pty.  Note that this may */
1548   /* cause EMACS not to die when it should, i.e., when its own controlling  */
1549   /* tty goes away.  I've complained to the AIX developers, and they may    */
1550   /* change this behavior, but I'm not going to hold my breath.             */
1551   signal (SIGHUP, SIG_IGN);
1552 #endif
1553 }
1554 #endif /* HAVE_PTYS */
1555 \f
1556 #ifdef VMS
1557
1558 /* Assigning an input channel is done at the start of Emacs execution.
1559    This is called each time Emacs is resumed, also, but does nothing
1560    because input_chain is no longer zero.  */
1561
1562 init_vms_input ()
1563 {
1564   int status;
1565
1566   if (input_fd == 0)
1567     {
1568       status = SYS$ASSIGN (&input_dsc, &input_fd, 0, 0);
1569       if (! (status & 1))
1570         LIB$STOP (status);
1571     }
1572 }
1573
1574 /* Deassigning the input channel is done before exiting.  */
1575
1576 stop_vms_input ()
1577 {
1578   return SYS$DASSGN (input_fd);
1579 }
1580
1581 short input_buffer;
1582
1583 /* Request reading one character into the keyboard buffer.
1584    This is done as soon as the buffer becomes empty.  */
1585
1586 queue_kbd_input ()
1587 {
1588   int status;
1589   extern kbd_input_ast ();
1590
1591   waiting_for_ast = 0;
1592   stop_input = 0;
1593   status = SYS$QIO (0, input_fd, IO$_READVBLK,
1594                     &input_iosb, kbd_input_ast, 1,
1595                     &input_buffer, 1, 0, terminator_mask, 0, 0);
1596 }
1597
1598 int input_count;
1599
1600 /* Ast routine that is called when keyboard input comes in
1601    in accord with the SYS$QIO above.  */
1602
1603 kbd_input_ast ()
1604 {
1605   register int c = -1;
1606   int old_errno = errno;
1607   extern EMACS_TIME *input_available_clear_time;
1608
1609   if (waiting_for_ast)
1610     SYS$SETEF (input_ef);
1611   waiting_for_ast = 0;
1612   input_count++;
1613 #ifdef ASTDEBUG
1614   if (input_count == 25)
1615     exit (1);
1616   printf ("Ast # %d,", input_count);
1617   printf (" iosb = %x, %x, %x, %x",
1618           input_iosb.offset, input_iosb.status, input_iosb.termlen,
1619           input_iosb.term);
1620 #endif
1621   if (input_iosb.offset)
1622     {
1623       c = input_buffer;
1624 #ifdef ASTDEBUG
1625       printf (", char = 0%o", c);
1626 #endif
1627     }
1628 #ifdef ASTDEBUG
1629   printf ("\n");
1630   fflush (stdout);
1631   sleep (1);
1632 #endif
1633   if (! stop_input)
1634     queue_kbd_input ();
1635   if (c >= 0)
1636     {
1637       struct input_event e;
1638       e.kind = ascii_keystroke;
1639       XSET (e.code, Lisp_Int, c);
1640 #ifdef MULTI_FRAME
1641       XSET(e.frame_or_window, Lisp_Frame, selected_frame);
1642 #else
1643       e.frame_or_window = Qnil;
1644 #endif
1645       kbd_buffer_store_event (&e);
1646     }
1647   if (input_available_clear_time)
1648     EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0);
1649   errno = old_errno;
1650 }
1651
1652 /* Wait until there is something in kbd_buffer.  */
1653
1654 wait_for_kbd_input ()
1655 {
1656   extern int have_process_input, process_exited;
1657
1658   /* If already something, avoid doing system calls.  */
1659   if (detect_input_pending ())
1660     {
1661       return;
1662     }
1663   /* Clear a flag, and tell ast routine above to set it.  */
1664   SYS$CLREF (input_ef);
1665   waiting_for_ast = 1;
1666   /* Check for timing error: ast happened while we were doing that.  */
1667   if (!detect_input_pending ())
1668     {
1669       /* No timing error: wait for flag to be set.  */
1670       set_waiting_for_input (0);
1671       SYS$WFLOR (input_ef, input_eflist);
1672       clear_waiting_for_input (0);
1673       if (!detect_input_pending ())
1674         /* Check for subprocess input availability */
1675         {
1676           int dsp = have_process_input || process_exited;
1677
1678           SYS$CLREF (process_ef);
1679           if (have_process_input)
1680             process_command_input ();
1681           if (process_exited)
1682             process_exit ();
1683           if (dsp)
1684             {
1685               update_mode_lines++;
1686               prepare_menu_bars ();
1687               redisplay_preserve_echo_area ();
1688             }
1689         }
1690     }
1691   waiting_for_ast = 0;
1692 }
1693
1694 /* Get rid of any pending QIO, when we are about to suspend
1695    or when we want to throw away pending input.
1696    We wait for a positive sign that the AST routine has run
1697    and therefore there is no I/O request queued when we return.
1698    SYS$SETAST is used to avoid a timing error.  */
1699
1700 end_kbd_input ()
1701 {
1702 #ifdef ASTDEBUG
1703   printf ("At end_kbd_input.\n");
1704   fflush (stdout);
1705   sleep (1);
1706 #endif
1707   if (LIB$AST_IN_PROG ())  /* Don't wait if suspending from kbd_buffer_store_event! */
1708     {
1709       SYS$CANCEL (input_fd);
1710       return;
1711     }
1712
1713   SYS$SETAST (0);
1714   /* Clear a flag, and tell ast routine above to set it.  */
1715   SYS$CLREF (input_ef);
1716   waiting_for_ast = 1;
1717   stop_input = 1;
1718   SYS$CANCEL (input_fd);
1719   SYS$SETAST (1);
1720   SYS$WAITFR (input_ef);
1721   waiting_for_ast = 0;
1722 }
1723
1724 /* Wait for either input available or time interval expiry.  */
1725
1726 input_wait_timeout (timeval)
1727      int timeval;               /* Time to wait, in seconds */
1728 {
1729   int time [2];
1730   static int zero = 0;
1731   static int large = -10000000;
1732
1733   LIB$EMUL (&timeval, &large, &zero, time);       /* Convert to VMS format */
1734
1735   /* If already something, avoid doing system calls.  */
1736   if (detect_input_pending ())
1737     {
1738       return;
1739     }
1740   /* Clear a flag, and tell ast routine above to set it.  */
1741   SYS$CLREF (input_ef);
1742   waiting_for_ast = 1;
1743   /* Check for timing error: ast happened while we were doing that.  */
1744   if (!detect_input_pending ())
1745     {
1746       /* No timing error: wait for flag to be set.  */
1747       SYS$CANTIM (1, 0);
1748       if (SYS$SETIMR (timer_ef, time, 0, 1) & 1) /* Set timer */
1749         SYS$WFLOR (timer_ef, timer_eflist);       /* Wait for timer expiry or input */
1750     }
1751   waiting_for_ast = 0;
1752 }
1753
1754 /* The standard `sleep' routine works some other way
1755    and it stops working if you have ever quit out of it.
1756    This one continues to work.  */
1757
1758 sys_sleep (timeval)
1759      int timeval;
1760 {
1761   int time [2];
1762   static int zero = 0;
1763   static int large = -10000000;
1764
1765   LIB$EMUL (&timeval, &large, &zero, time);       /* Convert to VMS format */
1766
1767   SYS$CANTIM (1, 0);
1768   if (SYS$SETIMR (timer_ef, time, 0, 1) & 1) /* Set timer */
1769     SYS$WAITFR (timer_ef);        /* Wait for timer expiry only */
1770 }
1771
1772 init_sigio ()
1773 {
1774   request_sigio ();
1775 }
1776
1777 reset_sigio ()
1778 {
1779   unrequest_sigio ();
1780 }
1781
1782 request_sigio ()
1783 {
1784   croak ("request sigio");
1785 }
1786
1787 unrequest_sigio ()
1788 {
1789   croak ("unrequest sigio");
1790 }
1791
1792 #endif /* VMS */
1793 \f
1794 /* Note that VMS compiler won't accept defined (CANNOT_DUMP).  */
1795 #ifndef CANNOT_DUMP
1796 #define NEED_STARTS
1797 #endif
1798
1799 #ifndef SYSTEM_MALLOC
1800 #ifndef NEED_STARTS
1801 #define NEED_STARTS
1802 #endif
1803 #endif
1804
1805 #ifdef NEED_STARTS
1806 /* Some systems that cannot dump also cannot implement these.  */
1807
1808 /*
1809  *      Return the address of the start of the text segment prior to
1810  *      doing an unexec.  After unexec the return value is undefined.
1811  *      See crt0.c for further explanation and _start.
1812  *
1813  */
1814
1815 #if !defined (CANNOT_UNEXEC) && !defined (HAVE_TEXT_START)
1816 char *
1817 start_of_text ()
1818 {
1819 #ifdef TEXT_START
1820   return ((char *) TEXT_START);
1821 #else
1822 #ifdef GOULD
1823   extern csrt ();
1824   return ((char *) csrt);
1825 #else /* not GOULD */
1826   extern int _start ();
1827   return ((char *) _start);
1828 #endif /* GOULD */
1829 #endif /* TEXT_START */
1830 }
1831 #endif /* not CANNOT_UNEXEC and not HAVE_TEXT_START */
1832
1833 /*
1834  *      Return the address of the start of the data segment prior to
1835  *      doing an unexec.  After unexec the return value is undefined.
1836  *      See crt0.c for further information and definition of data_start.
1837  *
1838  *      Apparently, on BSD systems this is etext at startup.  On
1839  *      USG systems (swapping) this is highly mmu dependent and
1840  *      is also dependent on whether or not the program is running
1841  *      with shared text.  Generally there is a (possibly large)
1842  *      gap between end of text and start of data with shared text.
1843  *
1844  *      On Uniplus+ systems with shared text, data starts at a
1845  *      fixed address.  Each port (from a given oem) is generally
1846  *      different, and the specific value of the start of data can
1847  *      be obtained via the UniPlus+ specific "uvar" system call,
1848  *      however the method outlined in crt0.c seems to be more portable.
1849  *
1850  *      Probably what will have to happen when a USG unexec is available,
1851  *      at least on UniPlus, is temacs will have to be made unshared so
1852  *      that text and data are contiguous.  Then once loadup is complete,
1853  *      unexec will produce a shared executable where the data can be
1854  *      at the normal shared text boundry and the startofdata variable
1855  *      will be patched by unexec to the correct value.
1856  *
1857  */
1858
1859 char *
1860 start_of_data ()
1861 {
1862 #ifdef DATA_START
1863   return ((char *) DATA_START);
1864 #else
1865 #ifdef ORDINARY_LINK
1866   /*
1867    * This is a hack.  Since we're not linking crt0.c or pre_crt0.c,
1868    * data_start isn't defined.  We take the address of environ, which
1869    * is known to live at or near the start of the system crt0.c, and
1870    * we don't sweat the handful of bytes that might lose.
1871    */
1872   extern char **environ;
1873
1874   return((char *) &environ);
1875 #else
1876   extern int data_start;
1877   return ((char *) &data_start);
1878 #endif /* ORDINARY_LINK */
1879 #endif /* DATA_START */
1880 }
1881 #endif /* NEED_STARTS (not CANNOT_DUMP or not SYSTEM_MALLOC) */
1882
1883 #ifndef CANNOT_DUMP
1884 /* Some systems that cannot dump also cannot implement these.  */
1885
1886 /*
1887  *      Return the address of the end of the text segment prior to
1888  *      doing an unexec.  After unexec the return value is undefined.
1889  */
1890
1891 char *
1892 end_of_text ()
1893 {
1894 #ifdef TEXT_END
1895   return ((char *) TEXT_END);
1896 #else
1897   extern int etext;
1898   return ((char *) &etext);
1899 #endif
1900 }
1901
1902 /*
1903  *      Return the address of the end of the data segment prior to
1904  *      doing an unexec.  After unexec the return value is undefined.
1905  */
1906
1907 char *
1908 end_of_data ()
1909 {
1910 #ifdef DATA_END
1911   return ((char *) DATA_END);
1912 #else
1913   extern int edata;
1914   return ((char *) &edata);
1915 #endif
1916 }
1917
1918 #endif /* not CANNOT_DUMP */
1919 \f
1920 /* get_system_name returns as its value
1921  a string for the Lisp function system-name to return. */
1922
1923 #ifdef BSD4_1
1924 #include <whoami.h>
1925 #endif
1926
1927 /* Can't have this within the function since `static' is #defined to
1928    nothing for some USG systems.  */
1929 static char *get_system_name_cache;
1930 static int get_system_name_predump_p;
1931
1932 #ifndef BSD4_1
1933 #ifndef VMS
1934 #ifdef HAVE_SOCKETS
1935 #include <sys/socket.h>
1936 #include <netdb.h>
1937 #endif /* HAVE_SOCKETS */
1938 #endif /* not VMS */
1939 #endif /* not BSD4_1 */
1940
1941 char *
1942 get_system_name ()
1943 {
1944 #ifdef BSD4_1
1945   return sysname;
1946 #else
1947 #ifndef CANNOT_DUMP
1948   /* If the cached value is from before the dump, and we've dumped
1949      since then, then the cached value is no good. */
1950   if (get_system_name_predump_p && initialized && get_system_name_cache)
1951     {
1952       xfree (get_system_name_cache);
1953       get_system_name_cache = 0;
1954     }
1955 #endif
1956   if (!get_system_name_cache)
1957     {
1958       /* No cached value, so get the name from the system.  */
1959 #ifdef VMS
1960       char *sp;
1961       if ((sp = egetenv ("SYS$NODE")) == 0)
1962         sp = "vax-vms";
1963       else
1964         {
1965           char *end;
1966
1967           if ((end = index (sp, ':')) != 0)
1968             *end = '\0';
1969         }
1970       get_system_name_cache = (char *) xmalloc (strlen (sp) + 1);
1971       strcpy (get_system_name_cache, sp);
1972 #else
1973 #ifndef HAVE_GETHOSTNAME
1974       struct utsname uts;
1975       uname (&uts);
1976       get_system_name_cache = (char *) xmalloc (strlen (uts.nodename) + 1);
1977       strcpy (get_system_name_cache, uts.nodename);
1978 #else /* HAVE_GETHOSTNAME */
1979       {
1980         int hostname_size = 256;
1981         char *hostname = (char *) xmalloc (hostname_size);
1982
1983         /* Try to get the host name; if the buffer is too short, try
1984            again.  Apparently, the only indication gethostname gives of
1985            whether the buffer was large enough is the presence or absence
1986            of a '\0' in the string.  Eech.  */
1987         for (;;)
1988           {
1989             gethostname (hostname, hostname_size - 1);
1990             hostname[hostname_size - 1] = '\0';
1991
1992             /* Was the buffer large enough for the '\0'?  */
1993             if (strlen (hostname) < hostname_size - 1)
1994               break;
1995
1996             hostname_size <<= 1;
1997             hostname = (char *) xrealloc (hostname, hostname_size);
1998           }
1999         get_system_name_cache = hostname;
2000 #ifdef HAVE_SOCKETS
2001         /* Turn the hostname into the official, fully-qualified hostname.
2002            Don't do this if we're going to dump; this can confuse system
2003            libraries on some machines and make the dumped emacs core dump. */
2004 #ifndef CANNOT_DUMP
2005         if (initialized)
2006 #endif /* not CANNOT_DUMP */
2007           {
2008             struct hostent *hp = gethostbyname (hostname);
2009             if (hp)
2010               {
2011                 char *fqdn = hp->h_name;
2012                 char *p;
2013
2014                 if (!index (fqdn, '.'))
2015                   {
2016                     /* We still don't have a fully qualified domain name.
2017                        Try to find one in the list of alternate names */
2018                     char **alias = hp->h_aliases;
2019                     while (*alias && !index (*alias, '.'))
2020                       alias++;
2021                     if (*alias)
2022                       fqdn = *alias;
2023                   }
2024                 hostname = (char *) xrealloc (hostname, strlen (fqdn) + 1);
2025                 strcpy (hostname, fqdn);
2026 #if 0
2027                 /* Convert the host name to lower case.  */
2028                 /* Using ctype.h here would introduce a possible locale
2029                    dependence that is probably wrong for hostnames.  */
2030                 p = hostname
2031                 while (*p)
2032                   {
2033                     if (*p >= 'A' && *p <= 'Z')
2034                       *p += 'a' - 'A';
2035                     p++;
2036                   }
2037 #endif
2038               }
2039           }
2040 #endif /* HAVE_SOCKETS */
2041         get_system_name_cache = hostname;
2042       }
2043 #endif /* HAVE_GETHOSTNAME */
2044 #endif /* VMS */
2045 #ifndef CANNOT_DUMP
2046       get_system_name_predump_p = !initialized;
2047 #endif
2048     }
2049   return (get_system_name_cache);
2050 #endif /* BSD4_1 */
2051 }
2052 \f
2053 #ifndef VMS
2054 #ifndef HAVE_SELECT
2055
2056 #ifdef HAVE_X_WINDOWS
2057 /* Cause explanatory error message at compile time,
2058    since the select emulation is not good enough for X.  */
2059 int *x = &x_windows_lose_if_no_select_system_call;
2060 #endif
2061
2062 /* Emulate as much as select as is possible under 4.1 and needed by Gnu Emacs
2063  * Only checks read descriptors.
2064  */
2065 /* How long to wait between checking fds in select */
2066 #define SELECT_PAUSE 1
2067 int select_alarmed;
2068
2069 /* For longjmp'ing back to read_input_waiting.  */
2070
2071 jmp_buf read_alarm_throw;
2072
2073 /* Nonzero if the alarm signal should throw back to read_input_waiting.
2074    The read_socket_hook function sets this to 1 while it is waiting.  */
2075
2076 int read_alarm_should_throw;
2077
2078 SIGTYPE
2079 select_alarm ()
2080 {
2081   select_alarmed = 1;
2082 #ifdef BSD4_1
2083   sigrelse (SIGALRM);
2084 #else /* not BSD4_1 */
2085   signal (SIGALRM, SIG_IGN);
2086 #endif /* not BSD4_1 */
2087   if (read_alarm_should_throw)
2088     longjmp (read_alarm_throw, 1);
2089 }
2090
2091 /* Only rfds are checked.  */
2092 int
2093 select (nfds, rfds, wfds, efds, timeout)
2094      int nfds;
2095      int *rfds, *wfds, *efds, *timeout;
2096 {
2097   int ravail = 0, orfds = 0, old_alarm;
2098   int timeoutval = timeout ? *timeout : 100000;
2099   int *local_timeout = &timeoutval;
2100   extern int proc_buffered_char[];
2101 #ifndef subprocesses
2102   int process_tick = 0, update_tick = 0;
2103 #else
2104   extern int process_tick, update_tick;
2105 #endif
2106   SIGTYPE (*old_trap) ();
2107   unsigned char buf;
2108
2109   if (rfds)
2110     {
2111       orfds = *rfds;
2112       *rfds = 0;
2113     }
2114   if (wfds)
2115     *wfds = 0;
2116   if (efds)
2117     *efds = 0;
2118
2119   /* If we are looking only for the terminal, with no timeout,
2120      just read it and wait -- that's more efficient.  */
2121   if (orfds == 1 && *local_timeout == 100000 && process_tick == update_tick)
2122     {
2123       if (! detect_input_pending ())
2124         read_input_waiting ();
2125       *rfds = 1;
2126       return 1;
2127     }
2128
2129   /* Once a second, till the timer expires, check all the flagged read
2130    * descriptors to see if any input is available.  If there is some then
2131    * set the corresponding bit in the return copy of rfds.
2132    */
2133   while (1)
2134     {
2135       register int to_check, bit, fd;
2136
2137       if (rfds)
2138         {
2139           for (to_check = nfds, bit = 1, fd = 0; --to_check >= 0; bit <<= 1, fd++)
2140             {
2141               if (orfds & bit)
2142                 {
2143                   int avail = 0, status = 0;
2144
2145                   if (bit == 1)
2146                     avail = detect_input_pending (); /* Special keyboard handler */
2147                   else
2148                     {
2149 #ifdef FIONREAD
2150                       status = ioctl (fd, FIONREAD, &avail);
2151 #else /* no FIONREAD */
2152 #ifdef MSDOS
2153                       abort (); /* I don't think we need it.  */
2154 #else /* not MSDOS */
2155                       /* Hoping it will return -1 if nothing available
2156                          or 0 if all 0 chars requested are read.  */
2157                       if (proc_buffered_char[fd] >= 0)
2158                         avail = 1;
2159                       else
2160                         {
2161                           avail = read (fd, &buf, 1);
2162                           if (avail > 0)
2163                             proc_buffered_char[fd] = buf;
2164                         }
2165 #endif /* not MSDOS */
2166 #endif /* no FIONREAD */
2167                     }
2168                   if (status >= 0 && avail > 0)
2169                     {
2170                       (*rfds) |= bit;
2171                       ravail++;
2172                     }
2173                 }
2174             }
2175         }
2176       if (*local_timeout == 0 || ravail != 0 || process_tick != update_tick)
2177         break;
2178       old_alarm = alarm (0);
2179       old_trap = signal (SIGALRM, select_alarm);
2180       select_alarmed = 0;
2181       alarm (SELECT_PAUSE);
2182       /* Wait for a SIGALRM (or maybe a SIGTINT) */
2183       while (select_alarmed == 0 && *local_timeout != 0
2184              && process_tick == update_tick)
2185         {
2186 #ifdef MSDOS
2187           sleep_or_kbd_hit (SELECT_PAUSE, (orfds & 1) != 0);
2188           select_alarm ();
2189 #else /* not MSDOS */
2190           /* If we are interested in terminal input,
2191              wait by reading the terminal.
2192              That makes instant wakeup for terminal input at least.  */
2193           if (orfds & 1)
2194             {
2195               read_input_waiting ();
2196               if (detect_input_pending ())
2197                 select_alarmed = 1;
2198             }
2199           else
2200             pause ();
2201 #endif /* not MSDOS */
2202         }
2203       (*local_timeout) -= SELECT_PAUSE;
2204       /* Reset the old alarm if there was one */
2205       alarm (0);
2206       signal (SIGALRM, old_trap);
2207       if (old_alarm != 0)
2208         {
2209           /* Reset or forge an interrupt for the original handler. */
2210           old_alarm -= SELECT_PAUSE;
2211           if (old_alarm <= 0)
2212             kill (getpid (), SIGALRM); /* Fake an alarm with the orig' handler */
2213           else
2214             alarm (old_alarm);
2215         }
2216       if (*local_timeout == 0)  /* Stop on timer being cleared */
2217         break;
2218     }
2219   return ravail;
2220 }
2221
2222 /* Read keyboard input into the standard buffer,
2223    waiting for at least one character.  */
2224
2225 /* Make all keyboard buffers much bigger when using X windows.  */
2226 #ifdef HAVE_X_WINDOWS
2227 #define BUFFER_SIZE_FACTOR 16
2228 #else
2229 #define BUFFER_SIZE_FACTOR 1
2230 #endif
2231
2232 read_input_waiting ()
2233 {
2234   struct input_event e;
2235   int nread, i;
2236   extern int quit_char;
2237
2238   if (read_socket_hook)
2239     {
2240       struct input_event buf[256];
2241
2242       read_alarm_should_throw = 0;
2243       if (! setjmp (read_alarm_throw))
2244         nread = (*read_socket_hook) (0, buf, 256, 1, 0);
2245       else
2246         nread = -1;
2247
2248       /* Scan the chars for C-g and store them in kbd_buffer.  */
2249       for (i = 0; i < nread; i++)
2250         {
2251           kbd_buffer_store_event (&buf[i]);
2252           /* Don't look at input that follows a C-g too closely.
2253              This reduces lossage due to autorepeat on C-g.  */
2254           if (buf[i].kind == ascii_keystroke
2255               && XINT(buf[i].code) == quit_char)
2256             break;
2257         }
2258     }
2259   else
2260     {
2261       char buf[3];
2262       nread = read (fileno (stdin), buf, 1);
2263
2264       /* Scan the chars for C-g and store them in kbd_buffer.  */
2265       e.kind = ascii_keystroke;
2266       e.frame_or_window = selected_frame;
2267       e.modifiers = 0;
2268       for (i = 0; i < nread; i++)
2269         {
2270           /* Convert chars > 0177 to meta events if desired.
2271              We do this under the same conditions that read_avail_input does.  */
2272           if (read_socket_hook == 0)
2273             {
2274               /* If the user says she has a meta key, then believe her. */
2275               if (meta_key == 1 && (buf[i] & 0x80))
2276                 e.modifiers = meta_modifier;
2277               if (meta_key != 2)
2278                 buf[i] &= ~0x80;
2279             }
2280
2281           XSET (e.code, Lisp_Int, buf[i]);
2282           kbd_buffer_store_event (&e);
2283           /* Don't look at input that follows a C-g too closely.
2284              This reduces lossage due to autorepeat on C-g.  */
2285           if (buf[i] == quit_char)
2286             break;
2287         }
2288     }
2289 }
2290
2291 #endif /* not HAVE_SELECT */
2292 #endif /* not VMS */
2293 \f
2294 #ifdef BSD4_1
2295 /*
2296  * Partially emulate 4.2 open call.
2297  * open is defined as this in 4.1.
2298  *
2299  * - added by Michael Bloom @ Citicorp/TTI
2300  *
2301  */
2302
2303 int
2304 sys_open (path, oflag, mode)
2305      char *path;
2306      int oflag, mode;
2307 {
2308   if (oflag & O_CREAT)
2309     return creat (path, mode);
2310   else
2311     return open (path, oflag);
2312 }
2313
2314 init_sigio ()
2315 {
2316   if (noninteractive)
2317     return;
2318   lmode = LINTRUP | lmode;
2319   ioctl (0, TIOCLSET, &lmode);
2320 }
2321
2322 reset_sigio ()
2323 {
2324   if (noninteractive)
2325     return;
2326   lmode = ~LINTRUP & lmode;
2327   ioctl (0, TIOCLSET, &lmode);
2328 }
2329
2330 request_sigio ()
2331 {
2332   sigrelse (SIGTINT);
2333
2334   interrupts_deferred = 0;
2335 }
2336
2337 unrequest_sigio ()
2338 {
2339   sighold (SIGTINT);
2340
2341   interrupts_deferred = 1;
2342 }
2343
2344 /* still inside #ifdef BSD4_1 */
2345 #ifdef subprocesses
2346
2347 int sigheld; /* Mask of held signals */
2348
2349 sigholdx (signum)
2350      int signum;
2351 {
2352   sigheld |= sigbit (signum);
2353   sighold (signum);
2354 }
2355
2356 sigisheld (signum)
2357      int signum;
2358 {
2359   sigheld |= sigbit (signum);
2360 }
2361
2362 sigunhold (signum)
2363      int signum;
2364 {
2365   sigheld &= ~sigbit (signum);
2366   sigrelse (signum);
2367 }
2368
2369 sigfree ()    /* Free all held signals */
2370 {
2371   int i;
2372   for (i = 0; i < NSIG; i++)
2373     if (sigheld & sigbit (i))
2374       sigrelse (i);
2375   sigheld = 0;
2376 }
2377
2378 sigbit (i)
2379 {
2380   return 1 << (i - 1);
2381 }
2382 #endif /* subprocesses */
2383 #endif /* BSD4_1 */
2384 \f
2385 /* POSIX signals support - DJB */
2386 /* Anyone with POSIX signals should have ANSI C declarations */
2387
2388 #ifdef POSIX_SIGNALS
2389
2390 sigset_t old_mask, empty_mask, full_mask, temp_mask;
2391 static struct sigaction new_action, old_action;
2392
2393 init_signals ()
2394 {
2395   sigemptyset (&empty_mask);
2396   sigfillset (&full_mask);
2397 }
2398
2399 signal_handler_t
2400 sys_signal (int signal_number, signal_handler_t action)
2401 {
2402 #ifdef DGUX
2403   /* This gets us restartable system calls for efficiency.
2404      The "else" code will works as well. */
2405   return (berk_signal (signal_number, action));
2406 #else
2407   sigemptyset (&new_action.sa_mask);
2408   new_action.sa_handler = action;
2409 #ifdef SA_RESTART
2410   /* Emacs mostly works better with restartable system services. If this
2411    * flag exists, we probably want to turn it on here.
2412    */
2413   new_action.sa_flags = SA_RESTART;
2414 #else
2415   new_action.sa_flags = 0;
2416 #endif
2417   sigaction (signal_number, &new_action, &old_action);
2418   return (old_action.sa_handler);
2419 #endif /* DGUX */
2420 }
2421
2422 #ifndef __GNUC__
2423 /* If we're compiling with GCC, we don't need this function, since it
2424    can be written as a macro.  */
2425 sigset_t
2426 sys_sigmask (int sig)
2427 {
2428   sigset_t mask;
2429   sigemptyset (&mask);
2430   sigaddset (&mask, sig);
2431   return mask;
2432 }
2433 #endif
2434
2435 int
2436 sys_sigpause (sigset_t new_mask)
2437 {
2438   /* pause emulating berk sigpause... */
2439   sigsuspend (&new_mask);
2440   return (EINTR);
2441 }
2442
2443 /* I'd like to have these guys return pointers to the mask storage in here,
2444    but there'd be trouble if the code was saving multiple masks.  I'll be
2445    safe and pass the structure.  It normally won't be more than 2 bytes
2446    anyhow. - DJB */
2447
2448 sigset_t
2449 sys_sigblock (sigset_t new_mask)
2450 {
2451   sigset_t old_mask;
2452   sigprocmask (SIG_BLOCK, &new_mask, &old_mask);
2453   return (old_mask);
2454 }
2455
2456 sigset_t
2457 sys_sigunblock (sigset_t new_mask)
2458 {
2459   sigset_t old_mask;
2460   sigprocmask (SIG_UNBLOCK, &new_mask, &old_mask);
2461   return (old_mask);
2462 }
2463
2464 sigset_t
2465 sys_sigsetmask (sigset_t new_mask)
2466 {
2467   sigset_t old_mask;
2468   sigprocmask (SIG_SETMASK, &new_mask, &old_mask);
2469   return (old_mask);
2470 }
2471
2472 #endif /* POSIX_SIGNALS */
2473 \f
2474 #ifndef BSTRING
2475
2476 #ifndef bzero
2477
2478 void
2479 bzero (b, length)
2480      register char *b;
2481      register int length;
2482 {
2483 #ifdef VMS
2484   short zero = 0;
2485   long max_str = 65535;
2486
2487   while (length > max_str) {
2488     (void) LIB$MOVC5 (&zero, &zero, &zero, &max_str, b);
2489     length -= max_str;
2490     b += max_str;
2491   }
2492   max_str = length;
2493   (void) LIB$MOVC5 (&zero, &zero, &zero, &max_str, b);
2494 #else
2495   while (length-- > 0)
2496     *b++ = 0;
2497 #endif /* not VMS */
2498 }
2499
2500 #endif /* no bzero */
2501
2502 #ifndef bcopy
2503 /* Saying `void' requires a declaration, above, where bcopy is used
2504    and that declaration causes pain for systems where bcopy is a macro.  */
2505 bcopy (b1, b2, length)
2506      register char *b1;
2507      register char *b2;
2508      register int length;
2509 {
2510 #ifdef VMS
2511   long max_str = 65535;
2512
2513   while (length > max_str) {
2514     (void) LIB$MOVC3 (&max_str, b1, b2);
2515     length -= max_str;
2516     b1 += max_str;
2517     b2 += max_str;
2518   }
2519   max_str = length;
2520   (void) LIB$MOVC3 (&length, b1, b2);
2521 #else
2522   while (length-- > 0)
2523     *b2++ = *b1++;
2524 #endif /* not VMS */
2525 }
2526 #endif /* no bcopy */
2527
2528 #ifndef bcmp
2529 int
2530 bcmp (b1, b2, length)   /* This could be a macro! */
2531      register char *b1;
2532      register char *b2;
2533      register int length;
2534 {
2535 #ifdef VMS
2536   struct dsc$descriptor_s src1 = {length, DSC$K_DTYPE_T, DSC$K_CLASS_S, b1};
2537   struct dsc$descriptor_s src2 = {length, DSC$K_DTYPE_T, DSC$K_CLASS_S, b2};
2538
2539   return STR$COMPARE (&src1, &src2);
2540 #else
2541   while (length-- > 0)
2542     if (*b1++ != *b2++)
2543       return 1;
2544
2545   return 0;
2546 #endif /* not VMS */
2547 }
2548 #endif /* no bcmp */
2549
2550 #endif /* not BSTRING */
2551 \f
2552 #ifndef HAVE_RANDOM
2553 #ifdef USG
2554 /*
2555  *      The BSD random returns numbers in the range of
2556  *      0 to 2e31 - 1.  The USG rand returns numbers in the
2557  *      range of 0 to 2e15 - 1.  This is probably not significant
2558  *      in this usage.
2559  */
2560
2561 long
2562 random ()
2563 {
2564   /* Arrange to return a range centered on zero.  */
2565   return (rand () << 15) + rand () - (1 << 29);
2566 }
2567
2568 srandom (arg)
2569      int arg;
2570 {
2571   srand (arg);
2572 }
2573
2574 #endif /* USG */
2575
2576 #ifdef BSD4_1
2577 long random ()
2578 {
2579   /* Arrange to return a range centered on zero.  */
2580   return (rand () << 15) + rand () - (1 << 29);
2581 }
2582
2583 srandom (arg)
2584      int arg;
2585 {
2586   srand (arg);
2587 }
2588 #endif /* BSD4_1 */
2589 #endif
2590 \f
2591 #ifdef WRONG_NAME_INSQUE
2592
2593 insque (q,p)
2594      caddr_t q,p;
2595 {
2596   _insque (q,p);
2597 }
2598
2599 #endif
2600 \f
2601 #ifdef VMS
2602
2603 #ifdef getenv
2604 /* If any place else asks for the TERM variable,
2605    allow it to be overridden with the EMACS_TERM variable
2606    before attempting to translate the logical name TERM.  As a last
2607    resort, ask for VAX C's special idea of the TERM variable.  */
2608 #undef getenv
2609 char *
2610 sys_getenv (name)
2611      char *name;
2612 {
2613   register char *val;
2614   static char buf[256];
2615   static struct dsc$descriptor_s equiv
2616     = {sizeof (buf), DSC$K_DTYPE_T, DSC$K_CLASS_S, buf};
2617   static struct dsc$descriptor_s d_name
2618     = {0, DSC$K_DTYPE_T, DSC$K_CLASS_S, 0};
2619   short eqlen;
2620
2621   if (!strcmp (name, "TERM"))
2622     {
2623       val = (char *) getenv ("EMACS_TERM");
2624       if (val)
2625         return val;
2626     }
2627
2628   d_name.dsc$w_length = strlen (name);
2629   d_name.dsc$a_pointer = name;
2630   if (LIB$SYS_TRNLOG (&d_name, &eqlen, &equiv) == 1)
2631     {
2632       char *str = (char *) xmalloc (eqlen + 1);
2633       bcopy (buf, str, eqlen);
2634       str[eqlen] = '\0';
2635       /* This is a storage leak, but a pain to fix.  With luck,
2636          no one will ever notice.  */
2637       return str;
2638     }
2639   return (char *) getenv (name);
2640 }
2641 #endif /* getenv */
2642
2643 #ifdef abort
2644 /* Since VMS doesn't believe in core dumps, the only way to debug this beast is
2645    to force a call on the debugger from within the image. */
2646 #undef abort
2647 sys_abort ()
2648 {
2649   reset_sys_modes ();
2650   LIB$SIGNAL (SS$_DEBUG);
2651 }
2652 #endif /* abort */
2653 #endif /* VMS */
2654 \f
2655 #ifdef VMS
2656 #ifdef LINK_CRTL_SHARE
2657 #ifdef SHAREABLE_LIB_BUG
2658 /* Variables declared noshare and initialized in sharable libraries
2659    cannot be shared.  The VMS linker incorrectly forces you to use a private
2660    version which is uninitialized... If not for this "feature", we
2661    could use the C library definition of sys_nerr and sys_errlist. */
2662 int sys_nerr = 35;
2663 char *sys_errlist[] =
2664   {
2665     "error 0",
2666     "not owner",
2667     "no such file or directory",
2668     "no such process",
2669     "interrupted system call",
2670     "i/o error",
2671     "no such device or address",
2672     "argument list too long",
2673     "exec format error",
2674     "bad file number",
2675     "no child process",
2676     "no more processes",
2677     "not enough memory",
2678     "permission denied",
2679     "bad address",
2680     "block device required",
2681     "mount devices busy",
2682     "file exists",
2683     "cross-device link",
2684     "no such device",
2685     "not a directory",
2686     "is a directory",
2687     "invalid argument",
2688     "file table overflow",
2689     "too many open files",
2690     "not a typewriter",
2691     "text file busy",
2692     "file too big",
2693     "no space left on device",
2694     "illegal seek",
2695     "read-only file system",
2696     "too many links",
2697     "broken pipe",
2698     "math argument",
2699     "result too large",
2700     "I/O stream empty",
2701     "vax/vms specific error code nontranslatable error"
2702   };
2703 #endif /* SHAREABLE_LIB_BUG */
2704 #endif /* LINK_CRTL_SHARE */
2705 #endif /* VMS */
2706
2707 #ifndef HAVE_STRERROR
2708 char *
2709 strerror (errnum)
2710      int errnum;
2711 {
2712   extern char *sys_errlist[];
2713   extern int sys_nerr;
2714
2715   if (errnum >= 0 && errnum < sys_nerr)
2716     return sys_errlist[errnum];
2717   return (char *) "Unknown error";
2718 }
2719
2720 #endif /* ! HAVE_STRERROR */
2721 \f
2722 #ifdef INTERRUPTIBLE_OPEN
2723
2724 int
2725 /* VARARGS 2 */
2726 sys_open (path, oflag, mode)
2727      char *path;
2728      int oflag, mode;
2729 {
2730   register int rtnval;
2731
2732   while ((rtnval = open (path, oflag, mode)) == -1
2733          && (errno == EINTR));
2734   return (rtnval);
2735 }
2736
2737 #endif /* INTERRUPTIBLE_OPEN */
2738
2739 #ifdef INTERRUPTIBLE_CLOSE
2740
2741 sys_close (fd)
2742      int fd;
2743 {
2744   register int rtnval;
2745
2746   while ((rtnval = close (fd)) == -1
2747          && (errno == EINTR));
2748   return rtnval;
2749 }
2750
2751 #endif /* INTERRUPTIBLE_CLOSE */
2752
2753 #ifdef INTERRUPTIBLE_IO
2754
2755 int
2756 sys_read (fildes, buf, nbyte)
2757      int fildes;
2758      char *buf;
2759      unsigned int nbyte;
2760 {
2761   register int rtnval;
2762
2763   while ((rtnval = read (fildes, buf, nbyte)) == -1
2764          && (errno == EINTR));
2765   return (rtnval);
2766 }
2767
2768 int
2769 sys_write (fildes, buf, nbyte)
2770      int fildes;
2771      char *buf;
2772      unsigned int nbyte;
2773 {
2774   register int rtnval, bytes_written;
2775
2776   bytes_written = 0;
2777
2778   while (nbyte > 0)
2779     {
2780       rtnval = write (fildes, buf, nbyte);
2781
2782       if (rtnval == -1)
2783         {
2784           if (errno == EINTR)
2785             continue;
2786           else
2787             return (bytes_written ? bytes_written : -1);
2788         }
2789
2790       buf += rtnval;
2791       nbyte -= rtnval;
2792       bytes_written += rtnval;
2793     }
2794   return (bytes_written);
2795 }
2796
2797 #endif /* INTERRUPTIBLE_IO */
2798 \f
2799 #ifndef HAVE_VFORK
2800
2801 /*
2802  *      Substitute fork for vfork on USG flavors.
2803  */
2804
2805 vfork ()
2806 {
2807   return (fork ());
2808 }
2809
2810 #endif /* not HAVE_VFORK */
2811 \f
2812 #ifdef USG
2813 /*
2814  *      All of the following are for USG.
2815  *
2816  *      On USG systems the system calls are INTERRUPTIBLE by signals
2817  *      that the user program has elected to catch.  Thus the system call
2818  *      must be retried in these cases.  To handle this without massive
2819  *      changes in the source code, we remap the standard system call names
2820  *      to names for our own functions in sysdep.c that do the system call
2821  *      with retries.  Actually, for portability reasons, it is good
2822  *      programming practice, as this example shows, to limit all actual
2823  *      system calls to a single occurrence in the source.  Sure, this
2824  *      adds an extra level of function call overhead but it is almost
2825  *      always negligible.   Fred Fish, Unisoft Systems Inc.
2826  */
2827
2828 #ifndef HAVE_SYS_SIGLIST
2829 char *sys_siglist[NSIG + 1] =
2830 {
2831 #ifdef AIX
2832 /* AIX has changed the signals a bit */
2833   "bogus signal",                       /* 0 */
2834   "hangup",                             /* 1  SIGHUP */
2835   "interrupt",                          /* 2  SIGINT */
2836   "quit",                               /* 3  SIGQUIT */
2837   "illegal instruction",                /* 4  SIGILL */
2838   "trace trap",                         /* 5  SIGTRAP */
2839   "IOT instruction",                    /* 6  SIGIOT */
2840   "crash likely",                       /* 7  SIGDANGER */
2841   "floating point exception",           /* 8  SIGFPE */
2842   "kill",                               /* 9  SIGKILL */
2843   "bus error",                          /* 10 SIGBUS */
2844   "segmentation violation",             /* 11 SIGSEGV */
2845   "bad argument to system call",        /* 12 SIGSYS */
2846   "write on a pipe with no one to read it", /* 13 SIGPIPE */
2847   "alarm clock",                        /* 14 SIGALRM */
2848   "software termination signum",        /* 15 SIGTERM */
2849   "user defined signal 1",              /* 16 SIGUSR1 */
2850   "user defined signal 2",              /* 17 SIGUSR2 */
2851   "death of a child",                   /* 18 SIGCLD */
2852   "power-fail restart",                 /* 19 SIGPWR */
2853   "bogus signal",                       /* 20 */
2854   "bogus signal",                       /* 21 */
2855   "bogus signal",                       /* 22 */
2856   "bogus signal",                       /* 23 */
2857   "bogus signal",                       /* 24 */
2858   "LAN I/O interrupt",                  /* 25 SIGAIO */
2859   "PTY I/O interrupt",                  /* 26 SIGPTY */
2860   "I/O intervention required",          /* 27 SIGIOINT */
2861   "HFT grant",                          /* 28 SIGGRANT */
2862   "HFT retract",                        /* 29 SIGRETRACT */
2863   "HFT sound done",                     /* 30 SIGSOUND */
2864   "HFT input ready",                    /* 31 SIGMSG */
2865 #else /* not AIX */
2866   "bogus signal",                       /* 0 */
2867   "hangup",                             /* 1  SIGHUP */
2868   "interrupt",                          /* 2  SIGINT */
2869   "quit",                               /* 3  SIGQUIT */
2870   "illegal instruction",                /* 4  SIGILL */
2871   "trace trap",                         /* 5  SIGTRAP */
2872   "IOT instruction",                    /* 6  SIGIOT */
2873   "EMT instruction",                    /* 7  SIGEMT */
2874   "floating point exception",           /* 8  SIGFPE */
2875   "kill",                               /* 9  SIGKILL */
2876   "bus error",                          /* 10 SIGBUS */
2877   "segmentation violation",             /* 11 SIGSEGV */
2878   "bad argument to system call",        /* 12 SIGSYS */
2879   "write on a pipe with no one to read it", /* 13 SIGPIPE */
2880   "alarm clock",                        /* 14 SIGALRM */
2881   "software termination signum",        /* 15 SIGTERM */
2882   "user defined signal 1",              /* 16 SIGUSR1 */
2883   "user defined signal 2",              /* 17 SIGUSR2 */
2884   "death of a child",                   /* 18 SIGCLD */
2885   "power-fail restart",                 /* 19 SIGPWR */
2886 #ifdef sun
2887   "window size change",                     /* 20 SIGWINCH */
2888   "urgent socket condition",                /* 21 SIGURG */
2889   "pollable event occured",                 /* 22 SIGPOLL */
2890   "stop (cannot be caught or ignored)", /*  23 SIGSTOP */
2891   "user stop requested from tty",           /* 24 SIGTSTP */
2892   "stopped process has been continued", /* 25 SIGCONT */
2893   "background tty read attempted",          /* 26 SIGTTIN */
2894   "background tty write attempted",    /* 27 SIGTTOU */
2895   "virtual timer expired",                  /* 28 SIGVTALRM */
2896   "profiling timer expired",                /* 29 SIGPROF */
2897   "exceeded cpu limit",                     /* 30 SIGXCPU */
2898   "exceeded file size limit",               /* 31 SIGXFSZ */
2899   "process's lwps are blocked",     /*  32 SIGWAITING */
2900   "special signal used by thread library", /* 33 SIGLWP */
2901   "Special Signal Used By CPR",     /* 34 SIGFREEZE */
2902   "Special Signal Used By CPR",     /* 35 SIGTHAW */
2903 #endif /* sun */
2904 #endif /* not AIX */
2905   0
2906   };
2907 #endif /* HAVE_SYS_SIGLIST */
2908
2909 /*
2910  *      Warning, this function may not duplicate 4.2 action properly
2911  *      under error conditions.
2912  */
2913
2914 #ifndef MAXPATHLEN
2915 /* In 4.1, param.h fails to define this.  */
2916 #define MAXPATHLEN 1024
2917 #endif
2918
2919 #ifndef HAVE_GETWD
2920
2921 char *
2922 getwd (pathname)
2923      char *pathname;
2924 {
2925   char *npath, *spath;
2926   extern char *getcwd ();
2927
2928   BLOCK_INPUT;                  /* getcwd uses malloc */
2929   spath = npath = getcwd ((char *) 0, MAXPATHLEN);
2930   if (spath == 0)
2931     return spath;
2932   /* On Altos 3068, getcwd can return @hostname/dir, so discard
2933      up to first slash.  Should be harmless on other systems.  */
2934   while (*npath && *npath != '/')
2935     npath++;
2936   strcpy (pathname, npath);
2937   free (spath);                 /* getcwd uses malloc */
2938   UNBLOCK_INPUT;
2939   return pathname;
2940 }
2941
2942 #endif /* HAVE_GETWD */
2943
2944 /*
2945  *      Emulate rename using unlink/link.  Note that this is
2946  *      only partially correct.  Also, doesn't enforce restriction
2947  *      that files be of same type (regular->regular, dir->dir, etc).
2948  */
2949
2950 #ifndef HAVE_RENAME
2951
2952 rename (from, to)
2953      const char *from;
2954      const char *to;
2955 {
2956   if (access (from, 0) == 0)
2957     {
2958       unlink (to);
2959       if (link (from, to) == 0)
2960         if (unlink (from) == 0)
2961           return (0);
2962     }
2963   return (-1);
2964 }
2965
2966 #endif
2967
2968 #ifdef MISSING_UTIMES
2969
2970 /* HPUX (among others) sets HAVE_TIMEVAL but does not implement utimes.  */
2971
2972 utimes ()
2973 {
2974 }
2975 #endif
2976
2977 #ifdef IRIS_UTIME
2978
2979 /* The IRIS (3.5) has timevals, but uses sys V utime, and doesn't have the
2980    utimbuf structure defined anywhere but in the man page. */
2981
2982 struct utimbuf
2983  {
2984    long actime;
2985    long modtime;
2986  };
2987
2988 utimes (name, tvp)
2989      char *name;
2990      struct timeval tvp[];
2991 {
2992   struct utimbuf utb;
2993   utb.actime  = tvp[0].tv_sec;
2994   utb.modtime = tvp[1].tv_sec;
2995   utime (name, &utb);
2996 }
2997 #endif /* IRIS_UTIME */
2998
2999
3000 #ifdef HPUX
3001 #ifndef HAVE_PERROR
3002
3003 /* HPUX curses library references perror, but as far as we know
3004    it won't be called.  Anyway this definition will do for now.  */
3005
3006 perror ()
3007 {
3008 }
3009
3010 #endif /* not HAVE_PERROR */
3011 #endif /* HPUX */
3012
3013 #ifndef HAVE_DUP2
3014
3015 /*
3016  *      Emulate BSD dup2.  First close newd if it already exists.
3017  *      Then, attempt to dup oldd.  If not successful, call dup2 recursively
3018  *      until we are, then close the unsuccessful ones.
3019  */
3020
3021 dup2 (oldd, newd)
3022      int oldd;
3023      int newd;
3024 {
3025   register int fd, ret;
3026
3027   sys_close (newd);
3028
3029 #ifdef F_DUPFD
3030   fd = fcntl (oldd, F_DUPFD, newd);
3031   if (fd != newd)
3032     error ("can't dup2 (%i,%i) : %s", oldd, newd, strerror (errno));
3033 #else
3034   fd = dup (old);
3035   if (fd == -1)
3036     return -1;
3037   if (fd == new)
3038     return new;
3039   ret = dup2 (old,new);
3040   sys_close (fd);
3041   return ret;
3042 #endif
3043 }
3044
3045 #endif /* not HAVE_DUP2 */
3046
3047 /*
3048  *      Gettimeofday.  Simulate as much as possible.  Only accurate
3049  *      to nearest second.  Emacs doesn't use tzp so ignore it for now.
3050  *      Only needed when subprocesses are defined.
3051  */
3052
3053 #ifdef subprocesses
3054 #ifndef VMS
3055 #ifndef HAVE_GETTIMEOFDAY
3056 #ifdef HAVE_TIMEVAL
3057
3058 /* ARGSUSED */
3059 gettimeofday (tp, tzp)
3060      struct timeval *tp;
3061      struct timezone *tzp;
3062 {
3063   extern long time ();
3064
3065   tp->tv_sec = time ((long *)0);
3066   tp->tv_usec = 0;
3067   if (tzp != 0)
3068     tzp->tz_minuteswest = -1;
3069 }
3070
3071 #endif
3072 #endif
3073 #endif
3074 #endif /* subprocess && !HAVE_GETTIMEOFDAY && HAVE_TIMEVAL && !VMS */
3075
3076 /*
3077  *      This function will go away as soon as all the stubs fixed. (fnf)
3078  */
3079
3080 croak (badfunc)
3081      char *badfunc;
3082 {
3083   printf ("%s not yet implemented\r\n", badfunc);
3084   reset_sys_modes ();
3085   exit (1);
3086 }
3087
3088 #endif /* USG */
3089 \f
3090 #ifdef DGUX
3091
3092 char *sys_siglist[NSIG + 1] =
3093 {
3094   "null signal",                         /*  0 SIGNULL   */
3095   "hangup",                              /*  1 SIGHUP    */
3096   "interrupt",                           /*  2 SIGINT    */
3097   "quit",                                /*  3 SIGQUIT   */
3098   "illegal instruction",                 /*  4 SIGILL    */
3099   "trace trap",                          /*  5 SIGTRAP   */
3100   "abort termination",                   /*  6 SIGABRT   */
3101   "SIGEMT",                              /*  7 SIGEMT    */
3102   "floating point exception",            /*  8 SIGFPE    */
3103   "kill",                                /*  9 SIGKILL   */
3104   "bus error",                           /* 10 SIGBUS    */
3105   "segmentation violation",              /* 11 SIGSEGV   */
3106   "bad argument to system call",         /* 12 SIGSYS    */
3107   "write on a pipe with no reader",      /* 13 SIGPIPE   */
3108   "alarm clock",                         /* 14 SIGALRM   */
3109   "software termination signal",         /* 15 SIGTERM   */
3110   "user defined signal 1",               /* 16 SIGUSR1   */
3111   "user defined signal 2",               /* 17 SIGUSR2   */
3112   "child stopped or terminated",         /* 18 SIGCLD    */
3113   "power-fail restart",                  /* 19 SIGPWR    */
3114   "window size changed",                 /* 20 SIGWINCH  */
3115   "undefined",                           /* 21           */
3116   "pollable event occurred",             /* 22 SIGPOLL   */
3117   "sendable stop signal not from tty",   /* 23 SIGSTOP   */
3118   "stop signal from tty",                /* 24 SIGSTP    */
3119   "continue a stopped process",          /* 25 SIGCONT   */
3120   "attempted background tty read",       /* 26 SIGTTIN   */
3121   "attempted background tty write",      /* 27 SIGTTOU   */
3122   "undefined",                           /* 28           */
3123   "undefined",                           /* 29           */
3124   "undefined",                           /* 30           */
3125   "undefined",                           /* 31           */
3126   "undefined",                           /* 32           */
3127   "socket (TCP/IP) urgent data arrival", /* 33 SIGURG    */
3128   "I/O is possible",                     /* 34 SIGIO     */
3129   "exceeded cpu time limit",             /* 35 SIGXCPU   */
3130   "exceeded file size limit",            /* 36 SIGXFSZ   */
3131   "virtual time alarm",                  /* 37 SIGVTALRM */
3132   "profiling time alarm",                /* 38 SIGPROF   */
3133   "undefined",                           /* 39           */
3134   "file record locks revoked",           /* 40 SIGLOST   */
3135   "undefined",                           /* 41           */
3136   "undefined",                           /* 42           */
3137   "undefined",                           /* 43           */
3138   "undefined",                           /* 44           */
3139   "undefined",                           /* 45           */
3140   "undefined",                           /* 46           */
3141   "undefined",                           /* 47           */
3142   "undefined",                           /* 48           */
3143   "undefined",                           /* 49           */
3144   "undefined",                           /* 50           */
3145   "undefined",                           /* 51           */
3146   "undefined",                           /* 52           */
3147   "undefined",                           /* 53           */
3148   "undefined",                           /* 54           */
3149   "undefined",                           /* 55           */
3150   "undefined",                           /* 56           */
3151   "undefined",                           /* 57           */
3152   "undefined",                           /* 58           */
3153   "undefined",                           /* 59           */
3154   "undefined",                           /* 60           */
3155   "undefined",                           /* 61           */
3156   "undefined",                           /* 62           */
3157   "undefined",                           /* 63           */
3158   "notification message in mess. queue", /* 64 SIGDGNOTIFY */
3159   0
3160 };
3161
3162 #endif /* DGUX */
3163 \f
3164 /* Directory routines for systems that don't have them. */
3165
3166 #ifdef SYSV_SYSTEM_DIR
3167
3168 #include <dirent.h>
3169
3170 #if defined(BROKEN_CLOSEDIR) || !defined(HAVE_CLOSEDIR)
3171
3172 int
3173 closedir (dirp)
3174      register DIR *dirp;              /* stream from opendir */
3175 {
3176   int rtnval;
3177
3178   rtnval = sys_close (dirp->dd_fd);
3179
3180   /* Some systems (like Solaris) allocate the buffer and the DIR all
3181      in one block.  Why in the world are we freeing this ourselves
3182      anyway?  */
3183 #if ! (defined (sun) && defined (USG5_4))
3184   xfree ((char *) dirp->dd_buf); /* directory block defined in <dirent.h> */
3185 #endif
3186   xfree ((char *) dirp);
3187
3188   return rtnval;
3189 }
3190 #endif /* BROKEN_CLOSEDIR or not HAVE_CLOSEDIR */
3191 #endif /* SYSV_SYSTEM_DIR */
3192
3193 #ifdef NONSYSTEM_DIR_LIBRARY
3194
3195 DIR *
3196 opendir (filename)
3197      char *filename;    /* name of directory */
3198 {
3199   register DIR *dirp;           /* -> malloc'ed storage */
3200   register int fd;              /* file descriptor for read */
3201   struct stat sbuf;             /* result of fstat */
3202
3203   fd = sys_open (filename, 0);
3204   if (fd < 0)
3205     return 0;
3206
3207   BLOCK_INPUT;
3208   if (fstat (fd, &sbuf) < 0
3209       || (sbuf.st_mode & S_IFMT) != S_IFDIR
3210       || (dirp = (DIR *) malloc (sizeof (DIR))) == 0)
3211     {
3212       sys_close (fd);
3213       UNBLOCK_INPUT;
3214       return 0;         /* bad luck today */
3215     }
3216   UNBLOCK_INPUT;
3217
3218   dirp->dd_fd = fd;
3219   dirp->dd_loc = dirp->dd_size = 0;     /* refill needed */
3220
3221   return dirp;
3222 }
3223
3224 void
3225 closedir (dirp)
3226      register DIR *dirp;                /* stream from opendir */
3227 {
3228   sys_close (dirp->dd_fd);
3229   xfree ((char *) dirp);
3230 }
3231
3232
3233 #ifndef VMS
3234 #define DIRSIZ  14
3235 struct olddir
3236   {
3237     ino_t od_ino;               /* inode */
3238     char od_name[DIRSIZ];       /* filename */
3239   };
3240 #endif /* not VMS */
3241
3242 struct direct dir_static;       /* simulated directory contents */
3243
3244 /* ARGUSED */
3245 struct direct *
3246 readdir (dirp)
3247      register DIR *dirp;        /* stream from opendir */
3248 {
3249 #ifndef VMS
3250   register struct olddir *dp;   /* -> directory data */
3251 #else /* VMS */
3252   register struct dir$_name *dp; /* -> directory data */
3253   register struct dir$_version *dv; /* -> version data */
3254 #endif /* VMS */
3255
3256   for (; ;)
3257     {
3258       if (dirp->dd_loc >= dirp->dd_size)
3259         dirp->dd_loc = dirp->dd_size = 0;
3260
3261       if (dirp->dd_size == 0    /* refill buffer */
3262           && (dirp->dd_size = sys_read (dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ)) <= 0)
3263         return 0;
3264
3265 #ifndef VMS
3266       dp = (struct olddir *) &dirp->dd_buf[dirp->dd_loc];
3267       dirp->dd_loc += sizeof (struct olddir);
3268
3269       if (dp->od_ino != 0)      /* not deleted entry */
3270         {
3271           dir_static.d_ino = dp->od_ino;
3272           strncpy (dir_static.d_name, dp->od_name, DIRSIZ);
3273           dir_static.d_name[DIRSIZ] = '\0';
3274           dir_static.d_namlen = strlen (dir_static.d_name);
3275           dir_static.d_reclen = sizeof (struct direct)
3276             - MAXNAMLEN + 3
3277               + dir_static.d_namlen - dir_static.d_namlen % 4;
3278           return &dir_static;   /* -> simulated structure */
3279         }
3280 #else /* VMS */
3281       dp = (struct dir$_name *) dirp->dd_buf;
3282       if (dirp->dd_loc == 0)
3283         dirp->dd_loc = (dp->dir$b_namecount&1) ? dp->dir$b_namecount + 1
3284           : dp->dir$b_namecount;
3285       dv = (struct dir$_version *)&dp->dir$t_name[dirp->dd_loc];
3286       dir_static.d_ino = dv->dir$w_fid_num;
3287       dir_static.d_namlen = dp->dir$b_namecount;
3288       dir_static.d_reclen = sizeof (struct direct)
3289         - MAXNAMLEN + 3
3290           + dir_static.d_namlen - dir_static.d_namlen % 4;
3291       strncpy (dir_static.d_name, dp->dir$t_name, dp->dir$b_namecount);
3292       dir_static.d_name[dir_static.d_namlen] = '\0';
3293       dirp->dd_loc = dirp->dd_size; /* only one record at a time */
3294       return &dir_static;
3295 #endif /* VMS */
3296     }
3297 }
3298
3299 #ifdef VMS
3300 /* readdirver is just like readdir except it returns all versions of a file
3301    as separate entries.  */
3302
3303 /* ARGUSED */
3304 struct direct *
3305 readdirver (dirp)
3306      register DIR *dirp;        /* stream from opendir */
3307 {
3308   register struct dir$_name *dp; /* -> directory data */
3309   register struct dir$_version *dv; /* -> version data */
3310
3311   if (dirp->dd_loc >= dirp->dd_size - sizeof (struct dir$_name))
3312     dirp->dd_loc = dirp->dd_size = 0;
3313
3314   if (dirp->dd_size == 0        /* refill buffer */
3315       && (dirp->dd_size = sys_read (dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ)) <= 0)
3316     return 0;
3317
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   strncpy (dir_static.d_name, dp->dir$t_name, dp->dir$b_namecount);
3324   sprintf (&dir_static.d_name[dp->dir$b_namecount], ";%d", dv->dir$w_version);
3325   dir_static.d_namlen = strlen (dir_static.d_name);
3326   dir_static.d_ino = dv->dir$w_fid_num;
3327   dir_static.d_reclen = sizeof (struct direct) - MAXNAMLEN + 3
3328                         + dir_static.d_namlen - dir_static.d_namlen % 4;
3329   dirp->dd_loc = ((char *) (++dv) - dp->dir$t_name);
3330   return &dir_static;
3331 }
3332
3333 #endif /* VMS */
3334
3335 #endif /* NONSYSTEM_DIR_LIBRARY */
3336
3337 \f
3338 /* mkdir and rmdir functions, for systems which don't have them.  */
3339
3340 #ifndef HAVE_MKDIR
3341 /*
3342  * Written by Robert Rother, Mariah Corporation, August 1985.
3343  *
3344  * If you want it, it's yours.  All I ask in return is that if you
3345  * figure out how to do this in a Bourne Shell script you send me
3346  * a copy.
3347  *                                      sdcsvax!rmr or rmr@uscd
3348  *
3349  * Severely hacked over by John Gilmore to make a 4.2BSD compatible
3350  * subroutine.  11Mar86; hoptoad!gnu
3351  *
3352  * Modified by rmtodd@uokmax 6-28-87 -- when making an already existing dir,
3353  * subroutine didn't return EEXIST.  It does now.
3354  */
3355
3356 /*
3357  * Make a directory.
3358  */
3359 #ifdef MKDIR_PROTOTYPE
3360 MKDIR_PROTOTYPE
3361 #else
3362 int
3363 mkdir (dpath, dmode)
3364      char *dpath;
3365      int dmode;
3366 #endif
3367 {
3368   int cpid, status, fd;
3369   struct stat statbuf;
3370
3371   if (stat (dpath, &statbuf) == 0)
3372     {
3373       errno = EEXIST;           /* Stat worked, so it already exists */
3374       return -1;
3375     }
3376
3377   /* If stat fails for a reason other than non-existence, return error */
3378   if (errno != ENOENT)
3379     return -1;
3380
3381   synch_process_alive = 1;
3382   switch (cpid = fork ())
3383     {
3384
3385     case -1:                    /* Error in fork */
3386       return (-1);              /* Errno is set already */
3387
3388     case 0:                     /* Child process */
3389       /*
3390                  * Cheap hack to set mode of new directory.  Since this
3391                  * child process is going away anyway, we zap its umask.
3392                  * FIXME, this won't suffice to set SUID, SGID, etc. on this
3393                  * directory.  Does anybody care?
3394                  */
3395       status = umask (0);       /* Get current umask */
3396       status = umask (status | (0777 & ~dmode));        /* Set for mkdir */
3397       fd = sys_open("/dev/null", 2);
3398       if (fd >= 0)
3399         {
3400           dup2 (fd, 0);
3401           dup2 (fd, 1);
3402           dup2 (fd, 2);
3403         }
3404       execl ("/bin/mkdir", "mkdir", dpath, (char *) 0);
3405       _exit (-1);               /* Can't exec /bin/mkdir */
3406
3407     default:                    /* Parent process */
3408       wait_for_termination (cpid);
3409     }
3410
3411   if (synch_process_death != 0 || synch_process_retcode != 0)
3412     {
3413       errno = EIO;              /* We don't know why, but */
3414       return -1;                /* /bin/mkdir failed */
3415     }
3416
3417   return 0;
3418 }
3419 #endif /* not HAVE_MKDIR */
3420
3421 #ifndef HAVE_RMDIR
3422 int
3423 rmdir (dpath)
3424      char *dpath;
3425 {
3426   int cpid, status, fd;
3427   struct stat statbuf;
3428
3429   if (stat (dpath, &statbuf) != 0)
3430     {
3431       /* Stat just set errno.  We don't have to */
3432       return -1;
3433     }
3434
3435   synch_process_alive = 1;
3436   switch (cpid = fork ())
3437     {
3438
3439     case -1:                    /* Error in fork */
3440       return (-1);              /* Errno is set already */
3441
3442     case 0:                     /* Child process */
3443       fd = sys_open("/dev/null", 2);
3444       if (fd >= 0)
3445         {
3446           dup2 (fd, 0);
3447           dup2 (fd, 1);
3448           dup2 (fd, 2);
3449         }
3450       wait_for_termination (cpid);
3451   if (synch_process_death != 0 || synch_process_retcode != 0)
3452       return -1;                /* /bin/rmdir failed */
3453     default:                    /* Parent process */
3454       while (cpid != wait (&status));   /* Wait for kid to finish */
3455     }
3456
3457   if (WIFSIGNALED (status) || WEXITSTATUS (status) != 0)
3458     {
3459       errno = EIO;              /* We don't know why, but */
3460       return -1;                /* /bin/mkdir failed */
3461     }
3462
3463   return 0;
3464 }
3465 #endif /* !HAVE_RMDIR */
3466
3467
3468 \f
3469 /* Functions for VMS */
3470 #ifdef VMS
3471 #include "vms-pwd.h"
3472 #include <acldef.h>
3473 #include <chpdef.h>
3474 #include <jpidef.h>
3475
3476 /* Return as a string the VMS error string pertaining to STATUS.
3477    Reuses the same static buffer each time it is called.  */
3478
3479 char *
3480 vmserrstr (status)
3481      int status;                /* VMS status code */
3482 {
3483   int bufadr[2];
3484   short len;
3485   static char buf[257];
3486
3487   bufadr[0] = sizeof buf - 1;
3488   bufadr[1] = (int) buf;
3489   if (! (SYS$GETMSG (status, &len, bufadr, 0x1, 0) & 1))
3490     return "untranslatable VMS error status";
3491   buf[len] = '\0';
3492   return buf;
3493 }
3494
3495 #ifdef access
3496 #undef access
3497
3498 /* The following is necessary because 'access' emulation by VMS C (2.0) does
3499  * not work correctly.  (It also doesn't work well in version 2.3.)
3500  */
3501
3502 #ifdef VMS4_4
3503
3504 #define DESCRIPTOR(name,string) struct dsc$descriptor_s name = \
3505         { strlen (string), DSC$K_DTYPE_T, DSC$K_CLASS_S, string }
3506
3507 typedef union {
3508     struct {
3509         unsigned short s_buflen;
3510         unsigned short s_code;
3511         char *s_bufadr;
3512         unsigned short *s_retlenadr;
3513     } s;
3514     int end;
3515 } item;
3516 #define buflen s.s_buflen
3517 #define code s.s_code
3518 #define bufadr s.s_bufadr
3519 #define retlenadr s.s_retlenadr
3520
3521 #define R_OK 4  /* test for read permission */
3522 #define W_OK 2  /* test for write permission */
3523 #define X_OK 1  /* test for execute (search) permission */
3524 #define F_OK 0  /* test for presence of file */
3525
3526 int
3527 sys_access (path, mode)
3528      char *path;
3529      int mode;
3530 {
3531   static char *user = NULL;
3532   char dir_fn[512];
3533
3534   /* translate possible directory spec into .DIR file name, so brain-dead
3535    * access can treat the directory like a file.  */
3536   if (directory_file_name (path, dir_fn))
3537     path = dir_fn;
3538
3539   if (mode == F_OK)
3540     return access (path, mode);
3541   if (user == NULL && (user = (char *) getenv ("USER")) == NULL)
3542     return -1;
3543   {
3544     int stat;
3545     int flags;
3546     int acces;
3547     unsigned short int dummy;
3548     item itemlst[3];
3549     static int constant = ACL$C_FILE;
3550     DESCRIPTOR (path_desc, path);
3551     DESCRIPTOR (user_desc, user);
3552
3553     flags = 0;
3554     acces = 0;
3555     if ((mode & X_OK) && ((stat = access (path, mode)) < 0 || mode == X_OK))
3556       return stat;
3557     if (mode & R_OK)
3558       acces |= CHP$M_READ;
3559     if (mode & W_OK)
3560       acces |= CHP$M_WRITE;
3561     itemlst[0].buflen = sizeof (int);
3562     itemlst[0].code = CHP$_FLAGS;
3563     itemlst[0].bufadr = (char *) &flags;
3564     itemlst[0].retlenadr = &dummy;
3565     itemlst[1].buflen = sizeof (int);
3566     itemlst[1].code = CHP$_ACCESS;
3567     itemlst[1].bufadr = (char *) &acces;
3568     itemlst[1].retlenadr = &dummy;
3569     itemlst[2].end = CHP$_END;
3570     stat = SYS$CHECK_ACCESS (&constant, &path_desc, &user_desc, itemlst);
3571     return stat == SS$_NORMAL ? 0 : -1;
3572   }
3573 }
3574
3575 #else /* not VMS4_4 */
3576
3577 #include <prvdef.h>
3578 #define ACE$M_WRITE     2
3579 #define ACE$C_KEYID     1
3580
3581 static unsigned short memid, grpid;
3582 static unsigned int uic;
3583
3584 /* Called from init_sys_modes, so it happens not very often
3585    but at least each time Emacs is loaded.  */
3586 sys_access_reinit ()
3587 {
3588   uic = 0;
3589 }
3590
3591 int
3592 sys_access (filename, type)
3593      char * filename;
3594      int type;
3595 {
3596   struct FAB fab;
3597   struct XABPRO xab;
3598   int status, size, i, typecode, acl_controlled;
3599   unsigned int *aclptr, *aclend, aclbuf[60];
3600   union prvdef prvmask;
3601
3602   /* Get UIC and GRP values for protection checking.  */
3603   if (uic == 0)
3604     {
3605       status = LIB$GETJPI (&JPI$_UIC, 0, 0, &uic, 0, 0);
3606       if (! (status & 1))
3607         return -1;
3608       memid = uic & 0xFFFF;
3609       grpid = uic >> 16;
3610     }
3611
3612   if (type != 2)                /* not checking write access */
3613     return access (filename, type);
3614
3615   /* Check write protection. */
3616
3617 #define CHECKPRIV(bit)    (prvmask.bit)
3618 #define WRITEABLE(field)  (! ((xab.xab$w_pro >> field) & XAB$M_NOWRITE))
3619
3620   /* Find privilege bits */
3621   status = SYS$SETPRV (0, 0, 0, prvmask);
3622   if (! (status & 1))
3623     error ("Unable to find privileges: %s", vmserrstr (status));
3624   if (CHECKPRIV (PRV$V_BYPASS))
3625     return 0;                   /* BYPASS enabled */
3626   fab = cc$rms_fab;
3627   fab.fab$b_fac = FAB$M_GET;
3628   fab.fab$l_fna = filename;
3629   fab.fab$b_fns = strlen (filename);
3630   fab.fab$l_xab = &xab;
3631   xab = cc$rms_xabpro;
3632   xab.xab$l_aclbuf = aclbuf;
3633   xab.xab$w_aclsiz = sizeof (aclbuf);
3634   status = SYS$OPEN (&fab, 0, 0);
3635   if (! (status & 1))
3636     return -1;
3637   SYS$CLOSE (&fab, 0, 0);
3638   /* Check system access */
3639   if (CHECKPRIV (PRV$V_SYSPRV) && WRITEABLE (XAB$V_SYS))
3640     return 0;
3641   /* Check ACL entries, if any */
3642   acl_controlled = 0;
3643   if (xab.xab$w_acllen > 0)
3644     {
3645       aclptr = aclbuf;
3646       aclend = &aclbuf[xab.xab$w_acllen / 4];
3647       while (*aclptr && aclptr < aclend)
3648         {
3649           size = (*aclptr & 0xff) / 4;
3650           typecode = (*aclptr >> 8) & 0xff;
3651           if (typecode == ACE$C_KEYID)
3652             for (i = size - 1; i > 1; i--)
3653               if (aclptr[i] == uic)
3654                 {
3655                   acl_controlled = 1;
3656                   if (aclptr[1] & ACE$M_WRITE)
3657                     return 0;   /* Write access through ACL */
3658                 }
3659           aclptr = &aclptr[size];
3660         }
3661       if (acl_controlled)       /* ACL specified, prohibits write access */
3662         return -1;
3663     }
3664   /* No ACL entries specified, check normal protection */
3665   if (WRITEABLE (XAB$V_WLD))    /* World writeable */
3666     return 0;
3667   if (WRITEABLE (XAB$V_GRP) &&
3668       (unsigned short) (xab.xab$l_uic >> 16) == grpid)
3669     return 0;                   /* Group writeable */
3670   if (WRITEABLE (XAB$V_OWN) &&
3671       (xab.xab$l_uic & 0xFFFF) == memid)
3672     return 0;                   /* Owner writeable */
3673
3674   return -1;    /* Not writeable */
3675 }
3676 #endif /* not VMS4_4 */
3677 #endif /* access */
3678
3679 static char vtbuf[NAM$C_MAXRSS+1];
3680
3681 /* translate a vms file spec to a unix path */
3682 char *
3683 sys_translate_vms (vfile)
3684      char * vfile;
3685 {
3686   char * p;
3687   char * targ;
3688
3689   if (!vfile)
3690     return 0;
3691
3692   targ = vtbuf;
3693
3694   /* leading device or logical name is a root directory */
3695   if (p = strchr (vfile, ':'))
3696     {
3697       *targ++ = '/';
3698       while (vfile < p)
3699         *targ++ = *vfile++;
3700       vfile++;
3701       *targ++ = '/';
3702     }
3703   p = vfile;
3704   if (*p == '[' || *p == '<')
3705     {
3706       while (*++vfile != *p + 2)
3707         switch (*vfile)
3708           {
3709           case '.':
3710             if (vfile[-1] == *p)
3711               *targ++ = '.';
3712             *targ++ = '/';
3713             break;
3714
3715           case '-':
3716             *targ++ = '.';
3717             *targ++ = '.';
3718             break;
3719
3720           default:
3721             *targ++ = *vfile;
3722             break;
3723           }
3724       vfile++;
3725       *targ++ = '/';
3726     }
3727   while (*vfile)
3728     *targ++ = *vfile++;
3729
3730   return vtbuf;
3731 }
3732
3733 static char utbuf[NAM$C_MAXRSS+1];
3734
3735 /* translate a unix path to a VMS file spec */
3736 char *
3737 sys_translate_unix (ufile)
3738      char * ufile;
3739 {
3740   int slash_seen = 0;
3741   char *p;
3742   char * targ;
3743
3744   if (!ufile)
3745     return 0;
3746
3747   targ = utbuf;
3748
3749   if (*ufile == '/')
3750     {
3751       ufile++;
3752     }
3753
3754   while (*ufile)
3755     {
3756       switch (*ufile)
3757         {
3758         case '/':
3759           if (slash_seen)
3760             if (index (&ufile[1], '/'))
3761               *targ++ = '.';
3762             else
3763               *targ++ = ']';
3764           else
3765             {
3766               *targ++ = ':';
3767               if (index (&ufile[1], '/'))
3768                 *targ++ = '[';
3769               slash_seen = 1;
3770             }
3771           break;
3772
3773         case '.':
3774           if (strncmp (ufile, "./", 2) == 0)
3775             {
3776               if (!slash_seen)
3777                 {
3778                   *targ++ = '[';
3779                   slash_seen = 1;
3780                 }
3781               ufile++;          /* skip the dot */
3782               if (index (&ufile[1], '/'))
3783                 *targ++ = '.';
3784               else
3785                 *targ++ = ']';
3786             }
3787           else if (strncmp (ufile, "../", 3) == 0)
3788             {
3789               if (!slash_seen)
3790                 {
3791                   *targ++ = '[';
3792                   slash_seen = 1;
3793                 }
3794               *targ++ = '-';
3795               ufile += 2;       /* skip the dots */
3796               if (index (&ufile[1], '/'))
3797                 *targ++ = '.';
3798               else
3799                 *targ++ = ']';
3800             }
3801           else
3802             *targ++ = *ufile;
3803           break;
3804
3805         default:
3806           *targ++ = *ufile;
3807           break;
3808         }
3809       ufile++;
3810     }
3811   *targ = '\0';
3812
3813   return utbuf;
3814 }
3815
3816 char *
3817 getwd (pathname)
3818      char *pathname;
3819 {
3820   char *ptr, *val;
3821   extern char *getcwd ();
3822
3823 #define MAXPATHLEN 1024
3824
3825   ptr = xmalloc (MAXPATHLEN);
3826   val = getcwd (ptr, MAXPATHLEN);
3827   if (val == 0)
3828     {
3829       xfree (ptr);
3830       return val;
3831     }
3832   strcpy (pathname, ptr);
3833   xfree (ptr);
3834
3835  return pathname;
3836 }
3837
3838 getppid ()
3839 {
3840   long item_code = JPI$_OWNER;
3841   unsigned long parent_id;
3842   int status;
3843
3844   if (((status = LIB$GETJPI (&item_code, 0, 0, &parent_id)) & 1) == 0)
3845     {
3846       errno = EVMSERR;
3847       vaxc$errno = status;
3848       return -1;
3849     }
3850   return parent_id;
3851 }
3852
3853 #undef getuid
3854 unsigned
3855 sys_getuid ()
3856 {
3857   return (getgid () << 16) | getuid ();
3858 }
3859
3860 int
3861 sys_read (fildes, buf, nbyte)
3862      int fildes;
3863      char *buf;
3864      unsigned int nbyte;
3865 {
3866   return read (fildes, buf, (nbyte < MAXIOSIZE ? nbyte : MAXIOSIZE));
3867 }
3868
3869 #if 0
3870 int
3871 sys_write (fildes, buf, nbyte)
3872      int fildes;
3873      char *buf;
3874      unsigned int nbyte;
3875 {
3876   register int nwrote, rtnval = 0;
3877
3878   while (nbyte > MAXIOSIZE && (nwrote = write (fildes, buf, MAXIOSIZE)) > 0) {
3879     nbyte -= nwrote;
3880     buf += nwrote;
3881     rtnval += nwrote;
3882   }
3883   if (nwrote < 0)
3884     return rtnval ? rtnval : -1;
3885   if ((nwrote = write (fildes, buf, nbyte)) < 0)
3886     return rtnval ? rtnval : -1;
3887   return (rtnval + nwrote);
3888 }
3889 #endif /* 0 */
3890
3891 /*
3892  *      VAX/VMS VAX C RTL really loses. It insists that records
3893  *      end with a newline (carriage return) character, and if they
3894  *      don't it adds one (nice of it isn't it!)
3895  *
3896  *      Thus we do this stupidity below.
3897  */
3898
3899 int
3900 sys_write (fildes, buf, nbytes)
3901      int fildes;
3902      char *buf;
3903      unsigned int nbytes;
3904 {
3905   register char *p;
3906   register char *e;
3907   int sum = 0;
3908   struct stat st;
3909
3910   fstat (fildes, &st);
3911   p = buf;
3912   while (nbytes > 0)
3913     {
3914       int len, retval;
3915
3916       /* Handle fixed-length files with carriage control.  */
3917       if (st.st_fab_rfm == FAB$C_FIX
3918           && ((st.st_fab_rat & (FAB$M_FTN | FAB$M_CR)) != 0))
3919         {
3920           len = st.st_fab_mrs;
3921           retval = write (fildes, p, min (len, nbytes));
3922           if (retval != len)
3923             return -1;
3924           retval++;     /* This skips the implied carriage control */
3925         }
3926       else
3927         {
3928           e =  p + min (MAXIOSIZE, nbytes) - 1;
3929           while (*e != '\n' && e > p) e--;
3930           if (p == e)           /* Ok.. so here we add a newline... sigh. */
3931             e = p + min (MAXIOSIZE, nbytes) - 1;
3932           len = e + 1 - p;
3933           retval = write (fildes, p, len);
3934           if (retval != len)
3935             return -1;
3936         }
3937       p += retval;
3938       sum += retval;
3939       nbytes -= retval;
3940     }
3941   return sum;
3942 }
3943
3944 /* Create file NEW copying its attributes from file OLD.  If
3945    OLD is 0 or does not exist, create based on the value of
3946    vms_stmlf_recfm. */
3947
3948 /* Protection value the file should ultimately have.
3949    Set by create_copy_attrs, and use by rename_sansversions.  */
3950 static unsigned short int fab_final_pro;
3951
3952 int
3953 creat_copy_attrs (old, new)
3954      char *old, *new;
3955 {
3956   struct FAB fab = cc$rms_fab;
3957   struct XABPRO xabpro;
3958   char aclbuf[256];     /* Choice of size is arbitrary.  See below. */
3959   extern int vms_stmlf_recfm;
3960
3961   if (old)
3962     {
3963       fab.fab$b_fac = FAB$M_GET;
3964       fab.fab$l_fna = old;
3965       fab.fab$b_fns = strlen (old);
3966       fab.fab$l_xab = (char *) &xabpro;
3967       xabpro = cc$rms_xabpro;
3968       xabpro.xab$l_aclbuf = aclbuf;
3969       xabpro.xab$w_aclsiz = sizeof aclbuf;
3970       /* Call $OPEN to fill in the fab & xabpro fields. */
3971       if (SYS$OPEN (&fab, 0, 0) & 1)
3972         {
3973           SYS$CLOSE (&fab, 0, 0);
3974           fab.fab$l_alq = 0;    /* zero the allocation quantity */
3975           if (xabpro.xab$w_acllen > 0)
3976             {
3977               if (xabpro.xab$w_acllen > sizeof aclbuf)
3978                 /* If the acl buffer was too short, redo open with longer one.
3979                    Wouldn't need to do this if there were some system imposed
3980                    limit on the size of an ACL, but I can't find any such. */
3981                 {
3982                   xabpro.xab$l_aclbuf = (char *) alloca (xabpro.xab$w_acllen);
3983                   xabpro.xab$w_aclsiz = xabpro.xab$w_acllen;
3984                   if (SYS$OPEN (&fab, 0, 0) & 1)
3985                     SYS$CLOSE (&fab, 0, 0);
3986                   else
3987                     old = 0;
3988                 }
3989             }
3990           else
3991             xabpro.xab$l_aclbuf = 0;
3992         }
3993       else
3994         old = 0;
3995     }
3996   fab.fab$l_fna = new;
3997   fab.fab$b_fns = strlen (new);
3998   if (!old)
3999     {
4000       fab.fab$l_xab = 0;
4001       fab.fab$b_rfm = vms_stmlf_recfm ? FAB$C_STMLF : FAB$C_VAR;
4002       fab.fab$b_rat = FAB$M_CR;
4003     }
4004
4005   /* Set the file protections such that we will be able to manipulate
4006      this file.  Once we are done writing and renaming it, we will set
4007      the protections back.  */
4008   if (old)
4009     fab_final_pro = xabpro.xab$w_pro;
4010   else
4011     SYS$SETDFPROT (0, &fab_final_pro);
4012   xabpro.xab$w_pro &= 0xff0f; /* set O:rewd for now. This is set back later. */
4013
4014   /* Create the new file with either default attrs or attrs copied
4015      from old file. */
4016   if (!(SYS$CREATE (&fab, 0, 0) & 1))
4017     return -1;
4018   SYS$CLOSE (&fab, 0, 0);
4019   /* As this is a "replacement" for creat, return a file descriptor
4020      opened for writing. */
4021   return open (new, O_WRONLY);
4022 }
4023
4024 #ifdef creat
4025 #undef creat
4026 #include <varargs.h>
4027 #ifdef __GNUC__
4028 #ifndef va_count
4029 #define va_count(X) ((X) = *(((int *) &(va_alist)) - 1))
4030 #endif
4031 #endif
4032
4033 sys_creat (va_alist)
4034      va_dcl
4035 {
4036   va_list list_incrementer;
4037   char *name;
4038   int mode;
4039   int rfd;                      /* related file descriptor */
4040   int fd;                       /* Our new file descriptor */
4041   int count;
4042   struct stat st_buf;
4043   char rfm[12];
4044   char rat[15];
4045   char mrs[13];
4046   char fsz[13];
4047   extern int vms_stmlf_recfm;
4048
4049   va_count (count);
4050   va_start (list_incrementer);
4051   name = va_arg (list_incrementer, char *);
4052   mode = va_arg (list_incrementer, int);
4053   if (count > 2)
4054     rfd = va_arg (list_incrementer, int);
4055   va_end (list_incrementer);
4056   if (count > 2)
4057     {
4058       /* Use information from the related file descriptor to set record
4059          format of the newly created file. */
4060       fstat (rfd, &st_buf);
4061       switch (st_buf.st_fab_rfm)
4062         {
4063         case FAB$C_FIX:
4064           strcpy (rfm, "rfm = fix");
4065           sprintf (mrs, "mrs = %d", st_buf.st_fab_mrs);
4066           strcpy (rat, "rat = ");
4067           if (st_buf.st_fab_rat & FAB$M_CR)
4068             strcat (rat, "cr");
4069           else if (st_buf.st_fab_rat & FAB$M_FTN)
4070             strcat (rat, "ftn");
4071           else if (st_buf.st_fab_rat & FAB$M_PRN)
4072             strcat (rat, "prn");
4073           if (st_buf.st_fab_rat & FAB$M_BLK)
4074             if (st_buf.st_fab_rat & (FAB$M_CR|FAB$M_FTN|FAB$M_PRN))
4075               strcat (rat, ", blk");
4076             else
4077               strcat (rat, "blk");
4078           return creat (name, 0, rfm, rat, mrs);
4079
4080         case FAB$C_VFC:
4081           strcpy (rfm, "rfm = vfc");
4082           sprintf (fsz, "fsz = %d", st_buf.st_fab_fsz);
4083           strcpy (rat, "rat = ");
4084           if (st_buf.st_fab_rat & FAB$M_CR)
4085             strcat (rat, "cr");
4086           else if (st_buf.st_fab_rat & FAB$M_FTN)
4087             strcat (rat, "ftn");
4088           else if (st_buf.st_fab_rat & FAB$M_PRN)
4089             strcat (rat, "prn");
4090           if (st_buf.st_fab_rat & FAB$M_BLK)
4091             if (st_buf.st_fab_rat & (FAB$M_CR|FAB$M_FTN|FAB$M_PRN))
4092               strcat (rat, ", blk");
4093             else
4094               strcat (rat, "blk");
4095           return creat (name, 0, rfm, rat, fsz);
4096
4097         case FAB$C_STM:
4098           strcpy (rfm, "rfm = stm");
4099           break;
4100
4101         case FAB$C_STMCR:
4102           strcpy (rfm, "rfm = stmcr");
4103           break;
4104
4105         case FAB$C_STMLF:
4106           strcpy (rfm, "rfm = stmlf");
4107           break;
4108
4109         case FAB$C_UDF:
4110           strcpy (rfm, "rfm = udf");
4111           break;
4112
4113         case FAB$C_VAR:
4114           strcpy (rfm, "rfm = var");
4115           break;
4116         }
4117       strcpy (rat, "rat = ");
4118       if (st_buf.st_fab_rat & FAB$M_CR)
4119         strcat (rat, "cr");
4120       else if (st_buf.st_fab_rat & FAB$M_FTN)
4121         strcat (rat, "ftn");
4122       else if (st_buf.st_fab_rat & FAB$M_PRN)
4123         strcat (rat, "prn");
4124       if (st_buf.st_fab_rat & FAB$M_BLK)
4125         if (st_buf.st_fab_rat & (FAB$M_CR|FAB$M_FTN|FAB$M_PRN))
4126           strcat (rat, ", blk");
4127         else
4128           strcat (rat, "blk");
4129     }
4130   else
4131     {
4132       strcpy (rfm, vms_stmlf_recfm ? "rfm = stmlf" : "rfm=var");
4133       strcpy (rat, "rat=cr");
4134     }
4135   /* Until the VAX C RTL fixes the many bugs with modes, always use
4136      mode 0 to get the user's default protection. */
4137   fd = creat (name, 0, rfm, rat);
4138   if (fd < 0 && errno == EEXIST)
4139     {
4140       if (unlink (name) < 0)
4141         report_file_error ("delete", build_string (name));
4142       fd = creat (name, 0, rfm, rat);
4143     }
4144   return fd;
4145 }
4146 #endif /* creat */
4147
4148 /* fwrite to stdout is S L O W.  Speed it up by using fputc...*/
4149 sys_fwrite (ptr, size, num, fp)
4150      register char * ptr;
4151      FILE * fp;
4152 {
4153   register int tot = num * size;
4154
4155   while (tot--)
4156     fputc (*ptr++, fp);
4157 }
4158
4159 /*
4160  * The VMS C library routine creat actually creates a new version of an
4161  * existing file rather than truncating the old version.  There are times
4162  * when this is not the desired behavior, for instance, when writing an
4163  * auto save file (you only want one version), or when you don't have
4164  * write permission in the directory containing the file (but the file
4165  * itself is writable).  Hence this routine, which is equivalent to
4166  * "close (creat (fn, 0));" on Unix if fn already exists.
4167  */
4168 int
4169 vms_truncate (fn)
4170      char *fn;
4171 {
4172   struct FAB xfab = cc$rms_fab;
4173   struct RAB xrab = cc$rms_rab;
4174   int status;
4175
4176   xfab.fab$l_fop = FAB$M_TEF;   /* free allocated but unused blocks on close */
4177   xfab.fab$b_fac = FAB$M_TRN | FAB$M_GET; /* allow truncate and get access */
4178   xfab.fab$b_shr = FAB$M_NIL;   /* allow no sharing - file must be locked */
4179   xfab.fab$l_fna = fn;
4180   xfab.fab$b_fns = strlen (fn);
4181   xfab.fab$l_dna = ";0";        /* default to latest version of the file */
4182   xfab.fab$b_dns = 2;
4183   xrab.rab$l_fab = &xfab;
4184
4185   /* This gibberish opens the file, positions to the first record, and
4186      deletes all records from there until the end of file. */
4187   if ((SYS$OPEN (&xfab) & 01) == 01)
4188     {
4189       if ((SYS$CONNECT (&xrab) & 01) == 01 &&
4190           (SYS$FIND (&xrab) & 01) == 01 &&
4191           (SYS$TRUNCATE (&xrab) & 01) == 01)
4192         status = 0;
4193       else
4194         status = -1;
4195     }
4196   else
4197     status = -1;
4198   SYS$CLOSE (&xfab);
4199   return status;
4200 }
4201
4202 /* Define this symbol to actually read SYSUAF.DAT.  This requires either
4203    SYSPRV or a readable SYSUAF.DAT. */
4204
4205 #ifdef READ_SYSUAF
4206 /*
4207  * getuaf.c
4208  *
4209  * Routine to read the VMS User Authorization File and return
4210  * a specific user's record.
4211  */
4212
4213 static struct UAF retuaf;
4214
4215 struct UAF *
4216 get_uaf_name (uname)
4217      char * uname;
4218 {
4219   register status;
4220   struct FAB uaf_fab;
4221   struct RAB uaf_rab;
4222
4223   uaf_fab = cc$rms_fab;
4224   uaf_rab = cc$rms_rab;
4225   /* initialize fab fields */
4226   uaf_fab.fab$l_fna = "SYS$SYSTEM:SYSUAF.DAT";
4227   uaf_fab.fab$b_fns = 21;
4228   uaf_fab.fab$b_fac = FAB$M_GET;
4229   uaf_fab.fab$b_org = FAB$C_IDX;
4230   uaf_fab.fab$b_shr = FAB$M_GET|FAB$M_PUT|FAB$M_UPD|FAB$M_DEL;
4231   /* initialize rab fields */
4232   uaf_rab.rab$l_fab = &uaf_fab;
4233   /* open the User Authorization File */
4234   status = SYS$OPEN (&uaf_fab);
4235   if (!(status&1))
4236     {
4237       errno = EVMSERR;
4238       vaxc$errno = status;
4239       return 0;
4240     }
4241   status = SYS$CONNECT (&uaf_rab);
4242   if (!(status&1))
4243     {
4244       errno = EVMSERR;
4245       vaxc$errno = status;
4246       return 0;
4247     }
4248   /* read the requested record - index is in uname */
4249   uaf_rab.rab$l_kbf = uname;
4250   uaf_rab.rab$b_ksz = strlen (uname);
4251   uaf_rab.rab$b_rac = RAB$C_KEY;
4252   uaf_rab.rab$l_ubf = (char *)&retuaf;
4253   uaf_rab.rab$w_usz = sizeof retuaf;
4254   status = SYS$GET (&uaf_rab);
4255   if (!(status&1))
4256     {
4257       errno = EVMSERR;
4258       vaxc$errno = status;
4259       return 0;
4260     }
4261   /* close the User Authorization File */
4262   status = SYS$DISCONNECT (&uaf_rab);
4263   if (!(status&1))
4264     {
4265       errno = EVMSERR;
4266       vaxc$errno = status;
4267       return 0;
4268     }
4269   status = SYS$CLOSE (&uaf_fab);
4270   if (!(status&1))
4271     {
4272       errno = EVMSERR;
4273       vaxc$errno = status;
4274       return 0;
4275     }
4276   return &retuaf;
4277 }
4278
4279 struct UAF *
4280 get_uaf_uic (uic)
4281      unsigned long uic;
4282 {
4283   register status;
4284   struct FAB uaf_fab;
4285   struct RAB uaf_rab;
4286
4287   uaf_fab = cc$rms_fab;
4288   uaf_rab = cc$rms_rab;
4289   /* initialize fab fields */
4290   uaf_fab.fab$l_fna = "SYS$SYSTEM:SYSUAF.DAT";
4291   uaf_fab.fab$b_fns = 21;
4292   uaf_fab.fab$b_fac = FAB$M_GET;
4293   uaf_fab.fab$b_org = FAB$C_IDX;
4294   uaf_fab.fab$b_shr = FAB$M_GET|FAB$M_PUT|FAB$M_UPD|FAB$M_DEL;
4295   /* initialize rab fields */
4296   uaf_rab.rab$l_fab = &uaf_fab;
4297   /* open the User Authorization File */
4298   status = SYS$OPEN (&uaf_fab);
4299   if (!(status&1))
4300     {
4301       errno = EVMSERR;
4302       vaxc$errno = status;
4303       return 0;
4304     }
4305   status = SYS$CONNECT (&uaf_rab);
4306   if (!(status&1))
4307     {
4308       errno = EVMSERR;
4309       vaxc$errno = status;
4310       return 0;
4311     }
4312   /* read the requested record - index is in uic */
4313   uaf_rab.rab$b_krf = 1;        /* 1st alternate key */
4314   uaf_rab.rab$l_kbf = (char *) &uic;
4315   uaf_rab.rab$b_ksz = sizeof uic;
4316   uaf_rab.rab$b_rac = RAB$C_KEY;
4317   uaf_rab.rab$l_ubf = (char *)&retuaf;
4318   uaf_rab.rab$w_usz = sizeof retuaf;
4319   status = SYS$GET (&uaf_rab);
4320   if (!(status&1))
4321     {
4322       errno = EVMSERR;
4323       vaxc$errno = status;
4324       return 0;
4325     }
4326   /* close the User Authorization File */
4327   status = SYS$DISCONNECT (&uaf_rab);
4328   if (!(status&1))
4329     {
4330       errno = EVMSERR;
4331       vaxc$errno = status;
4332       return 0;
4333     }
4334   status = SYS$CLOSE (&uaf_fab);
4335   if (!(status&1))
4336     {
4337       errno = EVMSERR;
4338       vaxc$errno = status;
4339       return 0;
4340     }
4341   return &retuaf;
4342 }
4343
4344 static struct passwd retpw;
4345
4346 struct passwd *
4347 cnv_uaf_pw (up)
4348      struct UAF * up;
4349 {
4350   char * ptr;
4351
4352   /* copy these out first because if the username is 32 chars, the next
4353      section will overwrite the first byte of the UIC */
4354   retpw.pw_uid = up->uaf$w_mem;
4355   retpw.pw_gid = up->uaf$w_grp;
4356
4357   /* I suppose this is not the best sytle, to possibly overwrite one
4358      byte beyond the end of the field, but what the heck... */
4359   ptr = &up->uaf$t_username[UAF$S_USERNAME];
4360   while (ptr[-1] == ' ')
4361     ptr--;
4362   *ptr = '\0';
4363   strcpy (retpw.pw_name, up->uaf$t_username);
4364
4365   /* the rest of these are counted ascii strings */
4366   strncpy (retpw.pw_gecos, &up->uaf$t_owner[1], up->uaf$t_owner[0]);
4367   retpw.pw_gecos[up->uaf$t_owner[0]] = '\0';
4368   strncpy (retpw.pw_dir, &up->uaf$t_defdev[1], up->uaf$t_defdev[0]);
4369   retpw.pw_dir[up->uaf$t_defdev[0]] = '\0';
4370   strncat (retpw.pw_dir, &up->uaf$t_defdir[1], up->uaf$t_defdir[0]);
4371   retpw.pw_dir[up->uaf$t_defdev[0] + up->uaf$t_defdir[0]] = '\0';
4372   strncpy (retpw.pw_shell, &up->uaf$t_defcli[1], up->uaf$t_defcli[0]);
4373   retpw.pw_shell[up->uaf$t_defcli[0]] = '\0';
4374
4375   return &retpw;
4376 }
4377 #else /* not READ_SYSUAF */
4378 static struct passwd retpw;
4379 #endif /* not READ_SYSUAF */
4380
4381 struct passwd *
4382 getpwnam (name)
4383      char * name;
4384 {
4385 #ifdef READ_SYSUAF
4386   struct UAF *up;
4387 #else
4388   char * user;
4389   char * dir;
4390   unsigned char * full;
4391 #endif /* READ_SYSUAF */
4392   char *ptr = name;
4393
4394   while (*ptr)
4395     {
4396       if ('a' <= *ptr && *ptr <= 'z')
4397         *ptr -= 040;
4398       ptr++;
4399     }
4400 #ifdef READ_SYSUAF
4401   if (!(up = get_uaf_name (name)))
4402     return 0;
4403   return cnv_uaf_pw (up);
4404 #else
4405   if (strcmp (name, getenv ("USER")) == 0)
4406     {
4407       retpw.pw_uid = getuid ();
4408       retpw.pw_gid = getgid ();
4409       strcpy (retpw.pw_name, name);
4410       if (full = egetenv ("FULLNAME"))
4411         strcpy (retpw.pw_gecos, full);
4412       else
4413         *retpw.pw_gecos = '\0';
4414       strcpy (retpw.pw_dir, egetenv ("HOME"));
4415       *retpw.pw_shell = '\0';
4416       return &retpw;
4417     }
4418   else
4419     return 0;
4420 #endif /* not READ_SYSUAF */
4421 }
4422
4423 struct passwd *
4424 getpwuid (uid)
4425      unsigned long uid;
4426 {
4427 #ifdef READ_SYSUAF
4428   struct UAF * up;
4429
4430   if (!(up = get_uaf_uic (uid)))
4431     return 0;
4432   return cnv_uaf_pw (up);
4433 #else
4434   if (uid == sys_getuid ())
4435     return getpwnam (egetenv ("USER"));
4436   else
4437     return 0;
4438 #endif /* not READ_SYSUAF */
4439 }
4440
4441 /* return total address space available to the current process.  This is
4442    the sum of the current p0 size, p1 size and free page table entries
4443    available. */
4444 vlimit ()
4445 {
4446   int item_code;
4447   unsigned long free_pages;
4448   unsigned long frep0va;
4449   unsigned long frep1va;
4450   register status;
4451
4452   item_code = JPI$_FREPTECNT;
4453   if (((status = LIB$GETJPI (&item_code, 0, 0, &free_pages)) & 1) == 0)
4454     {
4455       errno = EVMSERR;
4456       vaxc$errno = status;
4457       return -1;
4458     }
4459   free_pages *= 512;
4460
4461   item_code = JPI$_FREP0VA;
4462   if (((status = LIB$GETJPI (&item_code, 0, 0, &frep0va)) & 1) == 0)
4463     {
4464       errno = EVMSERR;
4465       vaxc$errno = status;
4466       return -1;
4467     }
4468   item_code = JPI$_FREP1VA;
4469   if (((status = LIB$GETJPI (&item_code, 0, 0, &frep1va)) & 1) == 0)
4470     {
4471       errno = EVMSERR;
4472       vaxc$errno = status;
4473       return -1;
4474     }
4475
4476   return free_pages + frep0va + (0x7fffffff - frep1va);
4477 }
4478
4479 define_logical_name (varname, string)
4480      char *varname;
4481      char *string;
4482 {
4483   struct dsc$descriptor_s strdsc =
4484     {strlen (string), DSC$K_DTYPE_T, DSC$K_CLASS_S, string};
4485   struct dsc$descriptor_s envdsc =
4486     {strlen (varname), DSC$K_DTYPE_T, DSC$K_CLASS_S, varname};
4487   struct dsc$descriptor_s lnmdsc =
4488     {7, DSC$K_DTYPE_T, DSC$K_CLASS_S, "LNM$JOB"};
4489
4490   return LIB$SET_LOGICAL (&envdsc, &strdsc, &lnmdsc, 0, 0);
4491 }
4492
4493 delete_logical_name (varname)
4494      char *varname;
4495 {
4496   struct dsc$descriptor_s envdsc =
4497     {strlen (varname), DSC$K_DTYPE_T, DSC$K_CLASS_S, varname};
4498   struct dsc$descriptor_s lnmdsc =
4499     {7, DSC$K_DTYPE_T, DSC$K_CLASS_S, "LNM$JOB"};
4500
4501   return LIB$DELETE_LOGICAL (&envdsc, &lnmdsc);
4502 }
4503
4504 ulimit ()
4505 {}
4506
4507 setpgrp ()
4508 {}
4509
4510 execvp ()
4511 {
4512   error ("execvp system call not implemented");
4513 }
4514
4515 int
4516 rename (from, to)
4517      char *from, *to;
4518 {
4519   int status;
4520   struct FAB from_fab = cc$rms_fab, to_fab = cc$rms_fab;
4521   struct NAM from_nam = cc$rms_nam, to_nam = cc$rms_nam;
4522   char from_esn[NAM$C_MAXRSS];
4523   char to_esn[NAM$C_MAXRSS];
4524
4525   from_fab.fab$l_fna = from;
4526   from_fab.fab$b_fns = strlen (from);
4527   from_fab.fab$l_nam = &from_nam;
4528   from_fab.fab$l_fop = FAB$M_NAM;
4529
4530   from_nam.nam$l_esa = from_esn;
4531   from_nam.nam$b_ess = sizeof from_esn;
4532
4533   to_fab.fab$l_fna = to;
4534   to_fab.fab$b_fns = strlen (to);
4535   to_fab.fab$l_nam = &to_nam;
4536   to_fab.fab$l_fop = FAB$M_NAM;
4537
4538   to_nam.nam$l_esa = to_esn;
4539   to_nam.nam$b_ess = sizeof to_esn;
4540
4541   status = SYS$RENAME (&from_fab, 0, 0, &to_fab);
4542
4543   if (status & 1)
4544     return 0;
4545   else
4546     {
4547       if (status == RMS$_DEV)
4548         errno = EXDEV;
4549       else
4550         errno = EVMSERR;
4551       vaxc$errno = status;
4552       return -1;
4553     }
4554 }
4555
4556 /* This function renames a file like `rename', but it strips
4557    the version number from the "to" filename, such that the "to" file is
4558    will always be a new version.  It also sets the file protection once it is
4559    finished.  The protection that we will use is stored in fab_final_pro,
4560    and was set when we did a creat_copy_attrs to create the file that we
4561    are renaming.
4562
4563    We could use the chmod function, but Eunichs uses 3 bits per user category
4564    to describe the protection, and VMS uses 4 (write and delete are separate
4565    bits).  To maintain portability, the VMS implementation of `chmod' wires
4566    the W and D bits together.  */
4567
4568
4569 static struct fibdef fib;       /* We need this initialized to zero */
4570 char vms_file_written[NAM$C_MAXRSS];
4571
4572 int
4573 rename_sans_version (from,to)
4574      char *from, *to;
4575 {
4576   short int chan;
4577   int stat;
4578   short int iosb[4];
4579   int status;
4580   struct FAB to_fab = cc$rms_fab;
4581   struct NAM to_nam = cc$rms_nam;
4582   struct dsc$descriptor fib_d ={sizeof (fib),0,0,(char*) &fib};
4583   struct dsc$descriptor fib_attr[2]
4584     = {{sizeof (fab_final_pro),ATR$C_FPRO,0,(char*) &fab_final_pro},{0,0,0,0}};
4585   char to_esn[NAM$C_MAXRSS];
4586
4587   $DESCRIPTOR (disk,to_esn);
4588
4589   to_fab.fab$l_fna = to;
4590   to_fab.fab$b_fns = strlen (to);
4591   to_fab.fab$l_nam = &to_nam;
4592   to_fab.fab$l_fop = FAB$M_NAM;
4593
4594   to_nam.nam$l_esa = to_esn;
4595   to_nam.nam$b_ess = sizeof to_esn;
4596
4597   status = SYS$PARSE (&to_fab, 0, 0); /* figure out the full file name */
4598
4599   if (to_nam.nam$l_fnb && NAM$M_EXP_VER)
4600     *(to_nam.nam$l_ver) = '\0';
4601
4602   stat = rename (from, to_esn);
4603   if (stat < 0)
4604     return stat;
4605
4606   strcpy (vms_file_written, to_esn);
4607
4608   to_fab.fab$l_fna = vms_file_written; /* this points to the versionless name */
4609   to_fab.fab$b_fns = strlen (vms_file_written);
4610
4611   /* Now set the file protection to the correct value */
4612   SYS$OPEN (&to_fab, 0, 0);     /* This fills in the nam$w_fid fields */
4613
4614   /* Copy these fields into the fib */
4615   fib.fib$r_fid_overlay.fib$w_fid[0] = to_nam.nam$w_fid[0];
4616   fib.fib$r_fid_overlay.fib$w_fid[1] = to_nam.nam$w_fid[1];
4617   fib.fib$r_fid_overlay.fib$w_fid[2] = to_nam.nam$w_fid[2];
4618
4619   SYS$CLOSE (&to_fab, 0, 0);
4620
4621   stat = SYS$ASSIGN (&disk, &chan, 0, 0); /* open a channel to the disk */
4622   if (!stat)
4623     LIB$SIGNAL (stat);
4624   stat = SYS$QIOW (0, chan, IO$_MODIFY, iosb, 0, 0, &fib_d,
4625                    0, 0, 0, &fib_attr, 0);
4626   if (!stat)
4627     LIB$SIGNAL (stat);
4628   stat = SYS$DASSGN (chan);
4629   if (!stat)
4630     LIB$SIGNAL (stat);
4631   strcpy (vms_file_written, to_esn); /* We will write this to the terminal*/
4632   return 0;
4633 }
4634
4635 link (file, new)
4636      char * file, * new;
4637 {
4638   register status;
4639   struct FAB fab;
4640   struct NAM nam;
4641   unsigned short fid[3];
4642   char esa[NAM$C_MAXRSS];
4643
4644   fab = cc$rms_fab;
4645   fab.fab$l_fop = FAB$M_OFP;
4646   fab.fab$l_fna = file;
4647   fab.fab$b_fns = strlen (file);
4648   fab.fab$l_nam = &nam;
4649
4650   nam = cc$rms_nam;
4651   nam.nam$l_esa = esa;
4652   nam.nam$b_ess = NAM$C_MAXRSS;
4653
4654   status = SYS$PARSE (&fab);
4655   if ((status & 1) == 0)
4656     {
4657       errno = EVMSERR;
4658       vaxc$errno = status;
4659       return -1;
4660     }
4661   status = SYS$SEARCH (&fab);
4662   if ((status & 1) == 0)
4663     {
4664       errno = EVMSERR;
4665       vaxc$errno = status;
4666       return -1;
4667     }
4668
4669   fid[0] = nam.nam$w_fid[0];
4670   fid[1] = nam.nam$w_fid[1];
4671   fid[2] = nam.nam$w_fid[2];
4672
4673   fab.fab$l_fna = new;
4674   fab.fab$b_fns = strlen (new);
4675
4676   status = SYS$PARSE (&fab);
4677   if ((status & 1) == 0)
4678     {
4679       errno = EVMSERR;
4680       vaxc$errno = status;
4681       return -1;
4682     }
4683
4684   nam.nam$w_fid[0] = fid[0];
4685   nam.nam$w_fid[1] = fid[1];
4686   nam.nam$w_fid[2] = fid[2];
4687
4688   nam.nam$l_esa = nam.nam$l_name;
4689   nam.nam$b_esl = nam.nam$b_name + nam.nam$b_type + nam.nam$b_ver;
4690
4691   status = SYS$ENTER (&fab);
4692   if ((status & 1) == 0)
4693     {
4694       errno = EVMSERR;
4695       vaxc$errno = status;
4696       return -1;
4697     }
4698
4699   return 0;
4700 }
4701
4702 croak (badfunc)
4703      char *badfunc;
4704 {
4705   printf ("%s not yet implemented\r\n", badfunc);
4706   reset_sys_modes ();
4707   exit (1);
4708 }
4709
4710 long
4711 random ()
4712 {
4713   /* Arrange to return a range centered on zero.  */
4714   return rand () - (1 << 30);
4715 }
4716
4717 srandom (seed)
4718 {
4719   srand (seed);
4720 }
4721 #endif /* VMS */
4722 \f
4723 #ifdef AIX
4724
4725 /* Called from init_sys_modes.  */
4726 hft_init ()
4727 {
4728   int junk;
4729
4730   /* If we're not on an HFT we shouldn't do any of this.  We determine
4731      if we are on an HFT by trying to get an HFT error code.  If this
4732      call fails, we're not on an HFT. */
4733 #ifdef IBMR2AIX
4734   if (ioctl (0, HFQERROR, &junk) < 0)
4735     return;
4736 #else /* not IBMR2AIX */
4737   if (ioctl (0, HFQEIO, 0) < 0)
4738     return;
4739 #endif /* not IBMR2AIX */
4740
4741   /* On AIX the default hft keyboard mapping uses backspace rather than delete
4742      as the rubout key's ASCII code.  Here this is changed.  The bug is that
4743      there's no way to determine the old mapping, so in reset_sys_modes
4744      we need to assume that the normal map had been present.  Of course, this
4745      code also doesn't help if on a terminal emulator which doesn't understand
4746      HFT VTD's. */
4747   {
4748     struct hfbuf buf;
4749     struct hfkeymap keymap;
4750
4751     buf.hf_bufp = (char *)&keymap;
4752     buf.hf_buflen = sizeof (keymap);
4753     keymap.hf_nkeys = 2;
4754     keymap.hfkey[0].hf_kpos = 15;
4755     keymap.hfkey[0].hf_kstate = HFMAPCHAR | HFSHFNONE;
4756 #ifdef IBMR2AIX
4757     keymap.hfkey[0].hf_keyidh = '<';
4758 #else /* not IBMR2AIX */
4759     keymap.hfkey[0].hf_page = '<';
4760 #endif /* not IBMR2AIX */
4761     keymap.hfkey[0].hf_char = 127;
4762     keymap.hfkey[1].hf_kpos = 15;
4763     keymap.hfkey[1].hf_kstate = HFMAPCHAR | HFSHFSHFT;
4764 #ifdef IBMR2AIX
4765     keymap.hfkey[1].hf_keyidh = '<';
4766 #else /* not IBMR2AIX */
4767     keymap.hfkey[1].hf_page = '<';
4768 #endif /* not IBMR2AIX */
4769     keymap.hfkey[1].hf_char = 127;
4770     hftctl (0, HFSKBD, &buf);
4771   }
4772   /* The HFT system on AIX doesn't optimize for scrolling, so it's really ugly
4773      at times.  */
4774   line_ins_del_ok = char_ins_del_ok = 0;
4775 }
4776
4777 /* Reset the rubout key to backspace. */
4778
4779 hft_reset ()
4780 {
4781   struct hfbuf buf;
4782   struct hfkeymap keymap;
4783   int junk;
4784
4785 #ifdef IBMR2AIX
4786   if (ioctl (0, HFQERROR, &junk) < 0)
4787     return;
4788 #else /* not IBMR2AIX */
4789   if (ioctl (0, HFQEIO, 0) < 0)
4790     return;
4791 #endif /* not IBMR2AIX */
4792
4793   buf.hf_bufp = (char *)&keymap;
4794   buf.hf_buflen = sizeof (keymap);
4795   keymap.hf_nkeys = 2;
4796   keymap.hfkey[0].hf_kpos = 15;
4797   keymap.hfkey[0].hf_kstate = HFMAPCHAR | HFSHFNONE;
4798 #ifdef IBMR2AIX
4799   keymap.hfkey[0].hf_keyidh = '<';
4800 #else /* not IBMR2AIX */
4801   keymap.hfkey[0].hf_page = '<';
4802 #endif /* not IBMR2AIX */
4803   keymap.hfkey[0].hf_char = 8;
4804   keymap.hfkey[1].hf_kpos = 15;
4805   keymap.hfkey[1].hf_kstate = HFMAPCHAR | HFSHFSHFT;
4806 #ifdef IBMR2AIX
4807   keymap.hfkey[1].hf_keyidh = '<';
4808 #else /* not IBMR2AIX */
4809   keymap.hfkey[1].hf_page = '<';
4810 #endif /* not IBMR2AIX */
4811   keymap.hfkey[1].hf_char = 8;
4812   hftctl (0, HFSKBD, &buf);
4813 }
4814
4815 #endif /* AIX */