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