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