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