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