src/sysdep.c

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