src/sysdep.c

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