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