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