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