1 /* Interfaces to system-dependent kernel and library entries.
2 Copyright (C) 1985-1988, 1992-1995 Free Software Foundation, Inc.
3 Copyright (C) 1995 Tinker Systems.
5 This file is part of XEmacs.
7 XEmacs is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 2, or (at your option) any
12 XEmacs is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with XEmacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* Synched up with: FSF 19.30 except for some Windows-NT crap. */
24 /* Substantially cleaned up by Ben Wing, Dec. 1994 / Jan. 1995. */
26 /* In this file, open, read and write refer to the system calls,
27 not our sugared interfaces sys_open, sys_read and sys_write.
30 #define DONT_ENCAPSULATE
37 /* <process.h> should not conflict with "process.h", as per ANSI definition.
38 This is not true though with visual c though. The trick below works with
39 VC4.2b and with VC5.0. It assumes that VC is installed in a kind of
40 standard way, so include files get to what/ever/path/include.
42 Unfortunately, this must go before lisp.h, since process.h defines abort()
43 which will conflict with the macro defined in lisp.h
45 #include <../include/process.h>
47 #include <mingw32/process.h>
49 #endif /* WINDOWSNT */
56 /* ------------------------------- */
58 /* ------------------------------- */
61 #include "console-tty.h"
63 #include "syssignal.h"
67 #include "console-stream.h"
72 #include "redisplay.h"
78 #ifdef HAVE_LIBGEN_H /* Must come before sysfile.h */
85 #if defined(WINDOWSNT) || defined(__CYGWIN32__)
86 #include "syssignal.h"
89 #include <sys/times.h>
93 #include <sys/utime.h>
98 /* ------------------------------- */
100 /* ------------------------------- */
103 #include <sys/utsname.h>
104 #if defined (TIOCGWINSZ) || defined (ISC4_0)
106 #include <sys/sioctl.h>
109 #include <sys/stream.h>
110 #include <sys/ptem.h>
112 #endif /* TIOCGWINSZ or ISC4_0 */
115 #ifdef HAVE_SYS_STROPTS_H
116 #include <sys/stropts.h>
117 #endif /* HAVE_SYS_STROPTS_H */
119 /* LPASS8 is new in 4.3, and makes cbreak mode provide all 8 bits. */
130 static int baud_convert[] =
135 0, 50, 75, 110, 135, 150, 200, 300, 600, 1200,
136 1800, 2400, 4800, 9600, 19200, 38400
143 static void hft_init (struct console *c);
144 static void hft_reset (struct console *c);
145 #include <sys/termio.h>
148 /* ------------------------------- */
150 /* ------------------------------- */
153 #ifndef HAVE_STRUCT_UTIMBUF
154 /* We want to use utime rather than utimes, but we couldn't find the
155 structure declaration. We'll use the traditional one. */
165 /************************************************************************/
166 /* subprocess control */
167 /************************************************************************/
173 /* Arrange for character C to be read as the next input from
176 stuff_char (struct console *con, int c)
180 assert (CONSOLE_TTY_P (con));
181 input_fd = CONSOLE_TTY_DATA (con)->infd;
182 /* Should perhaps error if in batch mode */
184 ioctl (input_fd, TIOCSTI, &c);
185 #else /* no TIOCSTI */
186 error ("Cannot stuff terminal input characters in this version of Unix.");
187 #endif /* no TIOCSTI */
192 #endif /* HAVE_TTY */
195 set_exclusive_use (int fd)
198 ioctl (fd, FIOCLEX, 0);
200 /* Ok to do nothing if this feature does not exist */
204 set_descriptor_non_blocking (int fd)
206 /* Stride people say it's a mystery why this is needed
207 as well as the O_NDELAY, but that it fails without this. */
208 /* For AIX: Apparently need this for non-blocking reads on sockets.
209 It seems that O_NONBLOCK applies only to FIFOs? From
210 lowry@watson.ibm.com (Andy Lowry). */
211 /* #### Should this be conditionalized on FIONBIO? */
212 #if defined (STRIDE) || (defined (pfa) && defined (HAVE_PTYS)) || defined (AIX)
215 ioctl (fd, FIONBIO, &one);
220 fcntl (fd, F_SETFL, O_NONBLOCK);
224 #if defined (NO_SUBPROCESSES)
228 wait_without_blocking (void)
230 wait3 (0, WNOHANG | WUNTRACED, 0);
231 synch_process_alive = 0;
235 #endif /* NO_SUBPROCESSES */
239 wait_for_termination (int pid)
241 /* #### With the new improved SIGCHLD handling stuff, there is much
242 less danger of race conditions and some of the comments below
243 don't apply. This should be updated. */
245 #if defined (NO_SUBPROCESSES)
248 /* No need to be tricky like below; we can just call wait(). */
249 /* #### should figure out how to write a wait_allowing_quit().
250 Since hardly any systems don't have subprocess support,
251 however, there doesn't seem to be much point. */
255 #elif defined (HAVE_WAITPID)
256 /* Note that, whenever any subprocess terminates (asynch. or synch.),
257 the SIGCHLD handler will be called and it will call wait(). Thus
258 we cannot just call wait() ourselves, and we can't block SIGCHLD
259 and then call wait(), because then if an asynch. process dies
260 while we're waiting for our synch. process, Emacs will never
261 notice that the asynch. process died.
263 So, the general approach we take is to repeatedly block until a
264 signal arrives, and then check if our process died using kill
265 (pid, 0). (We could also check the value of `synch_process_alive',
266 since the SIGCHLD handler will reset that and we know that we're
267 only being called on synchronous processes, but this approach is
268 safer. I don't trust the proper delivery of SIGCHLD.
270 Note also that we cannot use any form of waitpid(). A loop with
271 WNOHANG will chew up CPU time; better to use sleep(). A loop
272 without WNOWAIT will screw up the SIGCHLD handler (actually this
273 is not true, if you duplicate the exit-status-reaping code; see
274 below). A loop with WNOWAIT will result in a race condition if
275 the process terminates between the process-status check and the
276 call to waitpid(). */
278 /* Formerly, immediate_quit was set around this function call, but
279 that could lead to problems if the QUIT happened when SIGCHLD was
280 blocked -- it would remain blocked. Yet another reason why
281 immediate_quit is a bad idea. In any case, there is no reason to
282 resort to this because either the SIGIO or the SIGALRM will stop
283 the block in EMACS_WAIT_FOR_SIGNAL(). */
285 /* Apparently there are bugs on some systems with the second method
286 used below (the EMACS_BLOCK_SIGNAL method), whereby zombie
287 processes get left around. It appears in those cases that the
288 SIGCHLD handler is never getting invoked. It's not clear whether
289 this is an Emacs bug or a kernel bug or both: on HPUX this
290 problem is observed only with XEmacs, but under Solaris 2.4 all
291 sorts of different programs have problems with zombies. The
292 method we use here does not require a working SIGCHLD (but will
293 not break if it is working), and should be safe. */
295 We use waitpid(), contrary to the remarks above. There is no
296 race condition, because the three situations when sigchld_handler
297 is invoked should be handled OK:
299 - handler invoked before waitpid(): In this case, subprocess
300 status will be set by sigchld_handler. waitpid() here will
301 return -1 with errno set to ECHILD, which is a valid exit
304 - handler invoked during waitpid(): as above, except that errno
305 here will be set to EINTR. This will cause waitpid() to be
306 called again, and this time it will exit with ECHILD.
308 - handler invoked after waitpid(): The following code will reap
309 the subprocess. In the handler, wait() will return -1 because
310 there is no child to reap, and the handler will exit without
311 modifying child subprocess status. */
314 /* Because the SIGCHLD handler can potentially reap the synchronous
315 subprocess, we should take care of that. */
317 /* Will stay in the do loop as long as:
319 2. Ctrl-G is not pressed */
323 ret = waitpid (pid, &status, 0);
324 /* waitpid returns 0 if the process is still alive. */
326 while (ret == 0 || (ret == -1 && errno == EINTR));
328 if (ret == pid) /* Success */
329 /* Set synch process globals. This is can also happen
330 in sigchld_handler, and that code is duplicated. */
332 synch_process_alive = 0;
333 if (WIFEXITED (status))
334 synch_process_retcode = WEXITSTATUS (status);
335 else if (WIFSIGNALED (status))
336 synch_process_death = signal_name (WTERMSIG (status));
338 /* On exiting the loop, ret will be -1, with errno set to ECHILD if
339 the child has already been reaped, e.g. in the signal handler. */
341 /* Otherwise, we've had some error condition here.
342 Per POSIX, the only other possibilities are:
343 - EFAULT (bus error accessing arg 2) or
344 - EINVAL (incorrect arguments),
345 which are both program bugs.
347 Since implementations may add their own error indicators on top,
348 we ignore it by default. */
349 #elif defined (EMACS_BLOCK_SIGNAL) && !defined (BROKEN_WAIT_FOR_SIGNAL) && defined (SIGCHLD)
352 static int wait_debugging = 0; /* Set nonzero to make following
353 function work under dbx (at least for bsd). */
358 EMACS_BLOCK_SIGNAL (SIGCHLD);
359 /* Block SIGCHLD from happening during this check,
360 to avoid race conditions. */
361 if (kill (pid, 0) < 0)
363 EMACS_UNBLOCK_SIGNAL (SIGCHLD);
367 /* WARNING: Whatever this macro does *must* not allow SIGCHLD
368 to happen between the time that it's reenabled and when we
369 begin to block. Otherwise we may end up blocking for a
370 signal that has already arrived and isn't coming again.
371 Can you say "race condition"?
373 I assume that the system calls sigpause() or sigsuspend()
374 to provide this atomicness. If you're getting hangs in
375 sigpause()/sigsuspend(), then your OS doesn't implement
376 this properly (this applies under hpux9, for example).
377 Try defining BROKEN_WAIT_FOR_SIGNAL. */
378 EMACS_WAIT_FOR_SIGNAL (SIGCHLD);
380 #else /* not HAVE_WAITPID and (not EMACS_BLOCK_SIGNAL or BROKEN_WAIT_FOR_SIGNAL) */
381 /* This approach is kind of cheesy but is guaranteed(?!) to work
386 if (kill (pid, 0) < 0)
390 #endif /* OS features */
394 #if !defined (NO_SUBPROCESSES)
397 * flush any pending output
398 * (may flush input as well; it does not matter the way we use it)
402 flush_pending_output (int channel)
405 /* If we try this, we get hit with SIGTTIN, because
406 the child's tty belongs to the child's pgrp. */
407 #elif defined (TCFLSH)
408 ioctl (channel, TCFLSH, 1);
409 #elif defined (TIOCFLUSH)
411 /* 3rd arg should be ignored
412 but some 4.2 kernels actually want the address of an int
413 and nonzero means something different. */
414 ioctl (channel, TIOCFLUSH, &zero);
419 /* Set up the terminal at the other end of a pseudo-terminal that
420 we will be controlling an inferior through.
421 It should not echo or do line-editing, since that is done
422 in Emacs. No padding needed for insertion into an Emacs buffer. */
425 child_setup_tty (int out)
428 EMACS_GET_TTY (out, &s);
430 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
431 assert (isatty(out));
432 s.main.c_oflag |= OPOST; /* Enable output postprocessing */
433 s.main.c_oflag &= ~ONLCR; /* Disable map of NL to CR-NL on output */
435 s.main.c_oflag &= ~(NLDLY|CRDLY|TABDLY|BSDLY|VTDLY|FFDLY);
436 /* No output delays */
438 s.main.c_lflag &= ~ECHO; /* Disable echo */
439 s.main.c_lflag |= ISIG; /* Enable signals */
441 s.main.c_iflag &= ~IUCLC; /* Disable downcasing on input. */
444 s.main.c_oflag &= ~OLCUC; /* Disable upcasing on output. */
446 s.main.c_oflag &= ~TAB3; /* Disable tab expansion */
447 #if defined (CSIZE) && defined (CS8)
448 s.main.c_cflag = (s.main.c_cflag & ~CSIZE) | CS8; /* Don't strip 8th bit */
451 s.main.c_iflag &= ~ISTRIP; /* Don't strip 8th bit on input */
454 /* Unnecessary as long as ICANON is set */
455 s.main.c_cc[VMIN] = 1; /* minimum number of characters to accept */
456 s.main.c_cc[VTIME] = 0; /* wait forever for at least 1 character */
459 s.main.c_lflag |= ICANON; /* Enable erase/kill and eof processing */
460 s.main.c_cc[VEOF] = 04; /* ensure that EOF is Control-D */
461 s.main.c_cc[VERASE] = _POSIX_VDISABLE; /* disable erase processing */
462 s.main.c_cc[VKILL] = _POSIX_VDISABLE; /* disable kill processing */
465 s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
470 /* AIX enhanced edit loses NULs, so disable it. */
472 s.main.c_iflag &= ~ASCEDIT;
473 #endif /* IBMR2AIX */
474 /* Also, PTY overloads NUL and BREAK.
475 don't ignore break, but don't signal either, so it looks like NUL.
476 This really serves a purpose only if running in an XTERM window
477 or via TELNET or the like, but does no harm elsewhere. */
478 s.main.c_iflag &= ~IGNBRK;
479 s.main.c_iflag &= ~BRKINT;
481 #ifdef SIGNALS_VIA_CHARACTERS
482 /* TTY `special characters' are used in process_send_signal
483 so set them here to something useful. */
484 s.main.c_cc[VQUIT] = '\\'&037; /* Control-\ */
485 s.main.c_cc[VINTR] = 'C' &037; /* Control-C */
486 s.main.c_cc[VSUSP] = 'Z' &037; /* Control-Z */
487 #else /* no TIOCGPGRP or no TIOCGLTC or no TIOCGETC */
488 /* TTY `special characters' work better as signals, so disable
490 s.main.c_cc[VQUIT] = _POSIX_VDISABLE;
491 s.main.c_cc[VINTR] = _POSIX_VDISABLE;
492 s.main.c_cc[VSUSP] = _POSIX_VDISABLE;
493 s.main.c_lflag &= ~ISIG;
494 #endif /* no TIOCGPGRP or no TIOCGLTC or no TIOCGETC */
495 s.main.c_cc[VEOL] = _POSIX_VDISABLE;
497 /* <mdiers> ### This is not portable. ###
498 POSIX does not specify CBAUD, and 4.4BSD does not have it.
499 Instead, POSIX suggests to use cfset{i,o}speed().
500 [cf. D. Lewine, POSIX Programmer's Guide, Chapter 8: Terminal
501 I/O, O'Reilly 1991] */
502 s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
504 /* <mdiers> What to do upon failure? Just ignoring rc is probably
505 not acceptable, is it? */
506 if (cfsetispeed (&s.main, B9600) == -1) /* ignore */;
507 if (cfsetospeed (&s.main, B9600) == -1) /* ignore */;
508 #endif /* defined (CBAUD) */
510 #else /* not HAVE_TERMIO */
512 s.main.sg_flags &= ~(ECHO | CRMOD | ANYP | ALLDELAY | RAW | LCASE
514 s.main.sg_flags |= LPASS8;
515 s.main.sg_erase = 0377;
516 s.main.sg_kill = 0377;
517 s.lmode = LLITOUT | s.lmode; /* Don't strip 8th bit */
519 #endif /* not HAVE_TERMIO */
520 EMACS_SET_TTY (out, &s, 0);
525 ioctl (out, FIOASYNC, &zero);
529 #endif /* WINDOWSNT */
531 #endif /* not NO_SUBPROCESSES */
534 #if !defined (SIGTSTP) && !defined (USG_JOBCTRL)
536 #if defined(__STDC__) || defined(_MSC_VER)
537 #define SIG_PARAM_TYPE int
539 #define SIG_PARAM_TYPE
542 /* Record a signal code and the handler for it. */
546 SIGTYPE (*handler) (SIG_PARAM_TYPE);
550 save_signal_handlers (struct save_signal *saved_handlers)
552 while (saved_handlers->code)
554 saved_handlers->handler
555 = (SIGTYPE (*) (SIG_PARAM_TYPE)) signal (saved_handlers->code, SIG_IGN);
561 restore_signal_handlers (struct save_signal *saved_handlers)
563 while (saved_handlers->code)
565 signal (saved_handlers->code, saved_handlers->handler);
574 return abs (getpid ());
576 #endif /* WINDOWSNT */
578 /* Fork a subshell. */
583 struct save_signal saved_handlers[5];
585 unsigned char *str = 0;
589 saved_handlers[0].code = SIGINT;
590 saved_handlers[1].code = SIGQUIT;
591 saved_handlers[2].code = SIGTERM;
593 saved_handlers[3].code = SIGIO;
594 saved_handlers[4].code = 0;
596 saved_handlers[3].code = 0;
599 /* Mentioning current_buffer->buffer would mean including buffer.h,
600 which somehow wedges the hp compiler. So instead... */
602 if (NILP (Fboundp (Qdefault_directory)))
604 dir = Fsymbol_value (Qdefault_directory);
609 dir = Funhandled_file_name_directory (dir);
610 dir = expand_and_dir_to_file (dir, Qnil);
612 str = (unsigned char *) alloca (XSTRING_LENGTH (dir) + 2);
613 len = XSTRING_LENGTH (dir);
614 memcpy (str, XSTRING_DATA (dir), len);
615 /* #### Unix specific */
616 if (str[len - 1] != '/') str[len++] = '/';
622 #else /* not WINDOWSNT */
627 error ("Can't spawn subshell");
630 #endif /* not WINDOWSNT */
635 sh = (char *) egetenv ("SHELL");
639 /* Use our buffer's default directory for the subshell. */
643 #if !defined (NO_SUBPROCESSES) && !defined (WINDOWSNT)
644 close_process_descs (); /* Close Emacs's pipes/ptys */
647 #ifdef SET_EMACS_PRIORITY
648 if (emacs_priority != 0)
649 nice (-emacs_priority); /* Give the new shell the default priority */
653 /* Waits for process completion */
654 pid = _spawnlp (_P_WAIT, sh, sh, NULL);
656 write (1, "Can't execute subshell", 22);
658 #else /* not WINDOWSNT */
660 write (1, "Can't execute subshell", 22);
662 #endif /* not WINDOWSNT */
665 save_signal_handlers (saved_handlers);
666 synch_process_alive = 1;
667 wait_for_termination (pid);
668 restore_signal_handlers (saved_handlers);
671 #endif /* !defined (SIGTSTP) && !defined (USG_JOBCTRL) */
675 /* Suspend the Emacs process; give terminal to its superior. */
679 #if defined (SIGTSTP)
681 int pgrp = EMACS_GET_PROCESS_GROUP ();
682 EMACS_KILLPG (pgrp, SIGTSTP);
685 #elif defined (USG_JOBCTRL)
686 /* If you don't know what this is don't mess with it */
687 ptrace (0, 0, 0, 0); /* set for ptrace - caught by csh */
688 kill (getpid (), SIGQUIT);
690 #else /* No SIGTSTP or USG_JOBCTRL */
692 /* On a system where suspending is not implemented,
693 instead fork a subshell and let it talk directly to the terminal
700 /* Suspend a process if possible; give terminal to its superior. */
702 sys_suspend_process (int process)
704 /* I don't doubt that it is possible to suspend processes on
705 * VMS machines or thost that use USG_JOBCTRL,
706 * but I don't know how to do it, so...
708 #if defined (SIGTSTP)
709 kill(process, SIGTSTP);
714 /* Given FD, obtain pty buffer size. When no luck, a good guess is made,
715 so that the function works even fd is not a pty. */
718 get_pty_max_bytes (int fd)
722 #if defined (HAVE_FPATHCONF) && defined (_PC_MAX_CANON)
723 pty_max_bytes = fpathconf (fd, _PC_MAX_CANON);
724 if (pty_max_bytes < 0)
728 /* Deduct one, to leave space for the eof. */
731 return pty_max_bytes;
734 /* Figure out the eof character for the FD. */
737 get_eof_char (int fd)
739 CONST Bufbyte ctrl_d = (Bufbyte) '\004';
748 /* What is the following line designed to do??? -mrb */
749 if (strlen ((CONST char *) t.c_cc) < (unsigned int) (VEOF + 1))
752 return (Bufbyte) t.c_cc[VEOF];
754 return t.c_cc[VEOF] == _POSIX_VDISABLE ? ctrl_d : (Bufbyte) t.c_cc[VEOF];
756 #else /* ! HAVE_TERMIOS */
757 /* On Berkeley descendants, the following IOCTL's retrieve the
758 current control characters. */
759 #if defined (TIOCGETC)
762 ioctl (fd, TIOCGETC, &c);
763 return (Bufbyte) c.t_eofc;
765 #else /* ! defined (TIOCGLTC) && defined (TIOCGETC) */
766 /* On SYSV descendants, the TCGETA ioctl retrieves the current control
771 ioctl (fd, TCGETA, &t);
772 if (strlen ((CONST char *) t.c_cc) < (unsigned int) (VINTR + 1))
775 return (Bufbyte) t.c_cc[VINTR];
777 #else /* ! defined (TCGETA) */
778 /* Rather than complain, we'll just guess ^D, which is what
779 * earlier emacsen always used. */
781 #endif /* ! defined (TCGETA) */
782 #endif /* ! defined (TIOCGETC) */
783 #endif /* ! defined (HAVE_TERMIOS) */
786 /* Set the logical window size associated with descriptor FD
787 to HEIGHT and WIDTH. This is used mainly with ptys. */
790 set_window_size (int fd, int height, int width)
796 size.ws_row = height;
799 if (ioctl (fd, TIOCSWINSZ, &size) == -1)
800 return 0; /* error */
804 #elif defined (TIOCSSIZE)
808 size.ts_lines = height;
809 size.ts_cols = width;
811 if (ioctl (fd, TIOCGSIZE, &size) == -1)
822 /* Set up the proper status flags for use of a pty. */
827 /* I'm told that TOICREMOTE does not mean control chars
828 "can't be sent" but rather that they don't have
829 input-editing or signaling effects.
830 That should be good, because we have other ways
831 to do those things in Emacs.
832 However, telnet mode seems not to work on 4.2.
833 So TIOCREMOTE is turned off now. */
835 /* Under hp-ux, if TIOCREMOTE is turned on, some calls
836 will hang. In particular, the "timeout" feature (which
837 causes a read to return if there is no data available)
838 does this. Also it is known that telnet mode will hang
839 in such a way that Emacs must be stopped (perhaps this
840 is the same problem).
842 If TIOCREMOTE is turned off, then there is a bug in
843 hp-ux which sometimes loses data. Apparently the
844 code which blocks the master process when the internal
845 buffer fills up does not work. Other than this,
846 though, everything else seems to work fine.
848 Since the latter lossage is more benign, we may as well
849 lose that way. -- cph */
850 #if defined (FIONBIO) && defined (SYSV_PTYS)
853 ioctl (fd, FIONBIO, &on);
857 /* On AIX, the parent gets SIGHUP when a pty attached child dies. So, we */
858 /* ignore SIGHUP once we've started a child on a pty. Note that this may */
859 /* cause EMACS not to die when it should, i.e., when its own controlling */
860 /* tty goes away. I've complained to the AIX developers, and they may */
861 /* change this behavior, but I'm not going to hold my breath. */
862 signal (SIGHUP, SIG_IGN);
865 /* In some systems (Linux through 2.0.0, at least), packet mode doesn't
866 get cleared when a pty is closed, so we need to clear it here.
867 Linux pre2.0.13 contained an attempted fix for this (from Ted Ts'o,
868 tytso@mit.edu), but apparently it messed up rlogind and telnetd, so he
869 removed the fix in pre2.0.14. - dkindred@cs.cmu.edu
873 ioctl (fd, TIOCPKT, (char *)&off);
877 #endif /* HAVE_PTYS */
880 /************************************************************************/
882 /************************************************************************/
884 /* ------------------------------------------------------ */
886 /* ------------------------------------------------------ */
888 /* It really makes more sense for the baud-rate to be console-specific
889 and not device-specific, but it's (at least potentially) used for output
893 init_baud_rate (struct device *d)
895 struct console *con = XCONSOLE (DEVICE_CONSOLE (d));
896 if (DEVICE_WIN_P (d) || DEVICE_STREAM_P (d))
898 DEVICE_BAUD_RATE (d) = 38400;
903 assert (DEVICE_TTY_P (d));
905 int input_fd = CONSOLE_TTY_DATA (con)->infd;
906 #if defined (WINDOWSNT)
907 DEVICE_TTY_DATA (d)->ospeed = 15;
908 #elif defined (HAVE_TERMIOS)
912 tcgetattr (input_fd, &sg);
913 DEVICE_TTY_DATA (d)->ospeed = cfgetospeed (&sg);
914 # if defined (USE_GETOBAUD) && defined (getobaud)
915 /* m88k-motorola-sysv3 needs this (ghazi@noc.rutgers.edu) 9/1/94. */
916 if (DEVICE_TTY_DATA (d)->ospeed == 0)
917 DEVICE_TTY_DATA (d)->ospeed = getobaud (sg.c_cflag);
919 #elif defined (HAVE_TERMIO)
924 tcgetattr (input_fd, &sg);
926 ioctl (input_fd, TCGETA, &sg);
928 DEVICE_TTY_DATA (d)->ospeed = sg.c_cflag & CBAUD;
929 #else /* neither TERMIOS nor TERMIO */
932 sg.sg_ospeed = B9600;
933 if (ioctl (input_fd, TIOCGETP, &sg) < 0)
935 DEVICE_TTY_DATA (d)->ospeed = sg.sg_ospeed;
939 DEVICE_BAUD_RATE (d) =
940 (DEVICE_TTY_DATA (d)->ospeed < countof (baud_convert)
941 ? baud_convert[DEVICE_TTY_DATA (d)->ospeed]
944 if (DEVICE_BAUD_RATE (d) == 0)
945 DEVICE_BAUD_RATE (d) = 1200;
946 #endif /* HAVE_TTY */
950 /* ------------------------------------------------------ */
952 /* ------------------------------------------------------ */
954 #if defined(SIGIO) && !defined(BROKEN_SIGIO)
957 init_sigio_on_device (struct device *d)
959 int filedesc = DEVICE_INFD (d);
961 #if defined (FIOSSAIOOWN)
963 int owner = getpid ();
965 if (DEVICE_TTY_P (d))
967 ioctl_status = ioctl (filedesc, FIOGSAIOOWN,
968 &DEVICE_OLD_FCNTL_OWNER (d));
969 ioctl_status = ioctl (filedesc, FIOSSAIOOWN, &owner);
971 #ifdef HAVE_WINDOW_SYSTEM
972 else if (!DEVICE_STREAM_P (d))
974 ioctl_status = ioctl (filedesc, SIOCGPGRP,
975 &DEVICE_OLD_FCNTL_OWNER (d));
976 ioctl_status = ioctl (filedesc, SIOCSPGRP, &owner);
980 #elif defined (F_SETOWN) && !defined (F_SETOWN_BUG)
981 DEVICE_OLD_FCNTL_OWNER (d) = fcntl (filedesc, F_GETOWN, 0);
982 # ifdef F_SETOWN_SOCK_NEG
983 /* stdin is a socket here */
984 fcntl (filedesc, F_SETOWN, -getpid ());
986 fcntl (filedesc, F_SETOWN, getpid ());
992 reset_sigio_on_device (struct device *d)
994 int filedesc = DEVICE_INFD (d);
996 #if defined (FIOSSAIOOWN)
999 if (DEVICE_TTY_P (d))
1001 ioctl_status = ioctl (filedesc, FIOSSAIOOWN,
1002 &DEVICE_OLD_FCNTL_OWNER (d));
1004 #ifdef HAVE_WINDOW_SYSTEM
1005 else if (!DEVICE_STREAM_P (d))
1007 ioctl_status = ioctl (filedesc, SIOCSPGRP,
1008 &DEVICE_OLD_FCNTL_OWNER (d));
1012 #elif defined (F_SETOWN) && !defined (F_SETOWN_BUG)
1013 fcntl (filedesc, F_SETOWN, DEVICE_OLD_FCNTL_OWNER (d));
1018 request_sigio_on_device (struct device *d)
1020 int filedesc = DEVICE_INFD (d);
1022 #if defined (I_SETSIG) && !defined(HPUX10)
1025 ioctl (filedesc, I_GETSIG, &events);
1026 ioctl (filedesc, I_SETSIG, events | S_INPUT);
1028 #elif defined (FASYNC)
1029 fcntl (filedesc, F_SETFL, fcntl (filedesc, F_GETFL, 0) | FASYNC);
1030 #elif defined (FIOSSAIOSTAT)
1032 /* DG: Changed for HP-UX. HP-UX uses different IOCTLs for
1033 sockets and other devices for some bizarre reason. We guess
1034 that an X device is a socket, and tty devices aren't. We then
1035 use the following crud to do the appropriate thing. */
1037 int ioctl_status; /* ####DG: check if IOCTL succeeds here. */
1039 if (DEVICE_TTY_P (d))
1041 ioctl_status = ioctl (filedesc, FIOSSAIOSTAT, &on);
1043 #ifdef HAVE_WINDOW_SYSTEM
1044 else if (!DEVICE_STREAM_P (d))
1046 ioctl_status = ioctl (filedesc, FIOASYNC, &on);
1050 #elif defined (FIOASYNC)
1053 ioctl (filedesc, FIOASYNC, &on);
1057 #if defined (_CX_UX) /* #### Is this crap necessary? */
1058 EMACS_UNBLOCK_SIGNAL (SIGIO);
1063 unrequest_sigio_on_device (struct device *d)
1065 int filedesc = DEVICE_INFD (d);
1067 #if defined (I_SETSIG) && !defined(HPUX10)
1070 ioctl (filedesc, I_GETSIG, &events);
1071 ioctl (filedesc, I_SETSIG, events & ~S_INPUT);
1073 #elif defined (FASYNC)
1074 fcntl (filedesc, F_SETFL, fcntl (filedesc, F_GETFL, 0) & ~FASYNC);
1075 #elif defined (FIOSSAIOSTAT)
1077 /* DG: Changed for HP-UX. HP-UX uses different IOCTLs for
1078 sockets and other devices for some bizarre reason. We guess
1079 that an X device is a socket, and tty devices aren't. We then
1080 use the following crud to do the appropriate thing. */
1085 /* See comment for request_sigio_on_device */
1087 if (DEVICE_TTY_P (d))
1089 ioctl_status = ioctl (filedesc, FIOSSAIOSTAT, &off);
1093 ioctl_status = ioctl (filedesc, FIOASYNC, &off);
1096 #elif defined (FIOASYNC)
1099 ioctl (filedesc, FIOASYNC, &off);
1105 request_sigio (void)
1107 Lisp_Object devcons, concons;
1109 DEVICE_LOOP_NO_BREAK (devcons, concons)
1113 d = XDEVICE (XCAR (devcons));
1115 if (!DEVICE_STREAM_P (d))
1116 request_sigio_on_device (d);
1121 unrequest_sigio (void)
1123 Lisp_Object devcons, concons;
1125 DEVICE_LOOP_NO_BREAK (devcons, concons)
1129 d = XDEVICE (XCAR (devcons));
1131 if (!DEVICE_STREAM_P (d))
1132 unrequest_sigio_on_device (d);
1138 /* ------------------------------------------------------ */
1139 /* Changing Emacs's process group */
1140 /* ------------------------------------------------------ */
1142 /* Saving and restoring the process group of Emacs's terminal. */
1144 /* On some systems, apparently (?!) Emacs must be in its own process
1145 group in order to receive SIGIO correctly. On other systems
1146 (e.g. Solaris), it's not required and doing it makes things
1147 get fucked up. So, we only do it when
1148 SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP is defined. Basically,
1149 this is only required for BSD 4.2 systems. (Actually, I bet
1150 we don't have to do this at all -- those systems also
1151 required interrupt input, which we don't support.)
1153 If Emacs was in its own process group (i.e. inherited_pgroup ==
1154 getpid ()), then we know we're running under a shell with job
1155 control (Emacs would never be run as part of a pipeline).
1158 If Emacs was not in its own process group, then we know we're
1159 running under a shell (or a caller) that doesn't know how to
1160 separate itself from Emacs (like sh). Emacs must be in its own
1161 process group in order to receive SIGIO correctly. In this
1162 situation, we put ourselves in our own pgroup, forcibly set the
1163 tty's pgroup to our pgroup, and make sure to restore and reinstate
1164 the tty's pgroup just like any other terminal setting. If
1165 inherited_group was not the tty's pgroup, then we'll get a
1166 SIGTTmumble when we try to change the tty's pgroup, and a CONT if
1167 it goes foreground in the future, which is what should happen. */
1169 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1171 static int inherited_pgroup;
1172 static int inherited_tty_pgroup;
1177 munge_tty_process_group (void)
1179 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1183 /* Only do this munging if we have a device on the controlling
1184 terminal. See the large comment below. */
1186 if (CONSOLEP (Vcontrolling_terminal) &&
1187 CONSOLE_LIVE_P (XCONSOLE (Vcontrolling_terminal)))
1189 int fd = open ("/dev/tty", O_RDWR, 0);
1191 EMACS_BLOCK_SIGNAL (SIGTTOU);
1192 EMACS_SET_TTY_PROCESS_GROUP (fd, &me);
1193 EMACS_UNBLOCK_SIGNAL (SIGTTOU);
1199 /* Split off the foreground process group to Emacs alone.
1200 When we are in the foreground, but not started in our own process
1201 group, redirect the TTY to point to our own process group. We need
1202 to be in our own process group to receive SIGIO properly. */
1204 munge_process_groups (void)
1206 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1210 EMACS_SEPARATE_PROCESS_GROUP ();
1212 munge_tty_process_group ();
1217 unmunge_tty_process_group (void)
1219 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1221 int fd = open ("/dev/tty", O_RDWR, 0);
1222 EMACS_BLOCK_SIGNAL (SIGTTOU);
1223 EMACS_SET_TTY_PROCESS_GROUP (fd, &inherited_tty_pgroup);
1224 EMACS_UNBLOCK_SIGNAL (SIGTTOU);
1230 /* Set the tty to our original foreground group.
1231 Also restore the original process group (put us back into sh's
1232 process group), so that ^Z will suspend both us and sh. */
1234 unmunge_process_groups (void)
1236 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1240 unmunge_tty_process_group ();
1242 EMACS_SET_PROCESS_GROUP (inherited_pgroup);
1246 /* According to some old wisdom, we need to be in a separate process
1247 group for SIGIO to work correctly (at least on some systems ...).
1248 So go ahead and put ourselves into our own process group. This
1249 will fail if we're already in our own process group, but who cares.
1250 Also record whether we were in our own process group. (In general,
1251 we will already be in our own process group if we were started from
1252 a job-control shell like csh, but not if we were started from sh).
1254 If we succeeded in changing our process group, then we will no
1255 longer be in the foreground process group of our controlling
1256 terminal. Therefore, if we have a console open onto this terminal,
1257 we have to change the controlling terminal's foreground process
1258 group (otherwise we will get stopped with a SIGTTIN signal when
1259 attempting to read from the terminal). It's important,
1260 however, that we do this *only* when we have a console open onto
1261 the terminal. It's a decidedly bad idea to do so otherwise,
1262 especially if XEmacs was started from the background. */
1265 init_process_group (void)
1267 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1268 if (! noninteractive)
1270 int fd = open ("/dev/tty", O_RDWR, 0);
1271 inherited_pgroup = EMACS_GET_PROCESS_GROUP ();
1272 EMACS_GET_TTY_PROCESS_GROUP (fd, &inherited_tty_pgroup);
1274 EMACS_SEPARATE_PROCESS_GROUP ();
1280 disconnect_controlling_terminal (void)
1283 /* Controlling terminals are attached to a session.
1284 Create a new session for us; it will have no controlling
1285 terminal. This also, of course, puts us in our own
1289 /* Put us in our own process group. */
1290 EMACS_SEPARATE_PROCESS_GROUP ();
1291 # if defined (TIOCNOTTY)
1292 /* This is the older way of disconnecting the controlling
1293 terminal, on 4.3 BSD. We must open /dev/tty; using
1294 filedesc 0 is not sufficient because it could be
1295 something else (e.g. our stdin was redirected to
1299 int j = open ("/dev/tty", O_RDWR, 0);
1300 ioctl (j, TIOCNOTTY, 0);
1303 # endif /* TIOCNOTTY */
1305 On systems without TIOCNOTTY and without
1306 setsid(), we don't need to do anything more to
1307 disconnect our controlling terminal. Here is
1308 what the man page for termio(7) from a SYSV 3.2
1311 "The first terminal file opened by the process group leader
1312 of a terminal file not already associated with a process
1313 group becomes the control terminal for that process group.
1314 The control terminal plays a special role in handling quit
1315 and interrupt signals, as discussed below. The control
1316 terminal is inherited by a child process during a fork(2).
1317 A process can break this association by changing its process
1318 group using setpgrp(2)."
1321 # endif /* not HAVE_SETSID */
1325 /* ------------------------------------------------------ */
1326 /* Getting and setting emacs_tty structures */
1327 /* ------------------------------------------------------ */
1329 /* It's wrong to encase these into #ifdef HAVE_TTY because we need
1330 them for child TTY processes. */
1331 /* However, this does break NT support while we don't do child TTY processes */
1334 /* Set *TC to the parameters associated with the terminal FD.
1335 Return zero if all's well, or -1 if we ran into an error we
1336 couldn't deal with. */
1338 emacs_get_tty (int fd, struct emacs_tty *settings)
1340 /* Retrieve the primary parameters - baud rate, character size, etcetera. */
1342 /* We have those nifty POSIX tcmumbleattr functions. */
1343 if (tcgetattr (fd, &settings->main) < 0)
1346 #elif defined HAVE_TERMIO
1347 /* The SYSV-style interface? */
1348 if (ioctl (fd, TCGETA, &settings->main) < 0)
1351 #elif !defined (WINDOWSNT)
1352 /* I give up - I hope you have the BSD ioctls. */
1353 if (ioctl (fd, TIOCGETP, &settings->main) < 0)
1355 #endif /* HAVE_TCATTR */
1357 /* Suivant - Do we have to get struct ltchars data? */
1359 if (ioctl (fd, TIOCGLTC, &settings->ltchars) < 0)
1363 /* How about a struct tchars and a wordful of lmode bits? */
1365 if (ioctl (fd, TIOCGETC, &settings->tchars) < 0
1366 || ioctl (fd, TIOCLGET, &settings->lmode) < 0)
1370 /* We have survived the tempest. */
1374 /* Set the parameters of the tty on FD according to the contents of
1375 *SETTINGS. If FLUSHP is non-zero, we discard input.
1376 Return 0 if all went well, and -1 if anything failed. */
1379 emacs_set_tty (int fd, struct emacs_tty *settings, int flushp)
1381 /* Set the primary parameters - baud rate, character size, etcetera. */
1384 /* We have those nifty POSIX tcmumbleattr functions.
1385 William J. Smith <wjs@wiis.wang.com> writes:
1386 "POSIX 1003.1 defines tcsetattr() to return success if it was
1387 able to perform any of the requested actions, even if some
1388 of the requested actions could not be performed.
1389 We must read settings back to ensure tty setup properly.
1390 AIX requires this to keep tty from hanging occasionally." */
1391 /* This makes sure that we don't loop indefinitely in here. */
1392 for (i = 0 ; i < 10 ; i++)
1393 if (tcsetattr (fd, flushp ? TCSAFLUSH : TCSADRAIN, &settings->main) < 0)
1404 /* Get the current settings, and see if they're what we asked for. */
1405 tcgetattr (fd, &new);
1406 /* We cannot use memcmp on the whole structure here because under
1407 * aix386 the termios structure has some reserved field that may
1410 if ( new.c_iflag == settings->main.c_iflag
1411 && new.c_oflag == settings->main.c_oflag
1412 && new.c_cflag == settings->main.c_cflag
1413 && new.c_lflag == settings->main.c_lflag
1414 && memcmp(new.c_cc, settings->main.c_cc, NCCS) == 0)
1419 #elif defined HAVE_TERMIO
1420 /* The SYSV-style interface? */
1421 if (ioctl (fd, flushp ? TCSETAF : TCSETAW, &settings->main) < 0)
1424 #elif !defined (WINDOWSNT)
1425 /* I give up - I hope you have the BSD ioctls. */
1426 if (ioctl (fd, (flushp) ? TIOCSETP : TIOCSETN, &settings->main) < 0)
1428 #endif /* HAVE_TCATTR */
1430 /* Suivant - Do we have to get struct ltchars data? */
1432 if (ioctl (fd, TIOCSLTC, &settings->ltchars) < 0)
1436 /* How about a struct tchars and a wordful of lmode bits? */
1438 if (ioctl (fd, TIOCSETC, &settings->tchars) < 0
1439 || ioctl (fd, TIOCLSET, &settings->lmode) < 0)
1443 /* We have survived the tempest. */
1447 #endif /* WINDOWSNT */
1449 /* ------------------------------------------------------ */
1450 /* Initializing a device */
1451 /* ------------------------------------------------------ */
1455 /* This may also be defined in stdio,
1456 but if so, this does no harm,
1457 and using the same name avoids wasting the other one's space. */
1459 #if ((defined(USG) || defined(DGUX)) && !defined(__STDC__))
1460 char _sobuf[BUFSIZ+8];
1461 #elif (defined(USG) && !defined(LINUX) && !defined(_SCO_DS)) || defined(IRIX5)
1462 extern unsigned char _sobuf[BUFSIZ+8];
1464 char _sobuf[BUFSIZ];
1467 #if defined (TIOCGLTC) && defined (HAVE_LTCHARS) /* HAVE_LTCHARS */
1468 static struct ltchars new_ltchars = {-1,-1,-1,-1,-1,-1};
1470 #ifdef TIOCGETC /* HAVE_TCHARS */
1472 static struct tchars new_tchars = {-1,-1,-1,-1,-1,-1};
1477 tty_init_sys_modes_on_device (struct device *d)
1479 struct emacs_tty tty;
1480 int input_fd, output_fd;
1481 struct console *con = XCONSOLE (DEVICE_CONSOLE (d));
1483 input_fd = CONSOLE_TTY_DATA (con)->infd;
1484 output_fd = CONSOLE_TTY_DATA (con)->outfd;
1486 EMACS_GET_TTY (input_fd, &CONSOLE_TTY_DATA (con)->old_tty);
1487 tty = CONSOLE_TTY_DATA (con)->old_tty;
1489 con->tty_erase_char = Qnil;
1491 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
1492 /* after all those years... */
1493 con->tty_erase_char = make_char (tty.main.c_cc[VERASE]);
1495 /* This allows meta to be sent on 8th bit. */
1496 tty.main.c_iflag &= ~INPCK; /* don't check input for parity */
1498 tty.main.c_iflag |= (IGNBRK); /* Ignore break condition */
1499 tty.main.c_iflag &= ~ICRNL; /* Disable map of CR to NL on input */
1501 tty.main.c_iflag &= ~ISTRIP; /* don't strip 8th bit on input */
1503 tty.main.c_lflag &= ~ECHO; /* Disable echo */
1504 tty.main.c_lflag &= ~ICANON; /* Disable erase/kill processing */
1506 tty.main.c_lflag &= ~IEXTEN; /* Disable other editing characters. */
1508 tty.main.c_lflag |= ISIG; /* Enable signals */
1509 if (TTY_FLAGS (con).flow_control)
1511 tty.main.c_iflag |= IXON; /* Enable start/stop output control */
1513 tty.main.c_iflag &= ~IXANY;
1517 tty.main.c_iflag &= ~IXON; /* Disable start/stop output control */
1518 tty.main.c_oflag &= ~ONLCR; /* Disable map of NL to CR-NL
1520 tty.main.c_oflag &= ~TAB3; /* Disable tab expansion */
1522 if (TTY_FLAGS (con).meta_key)
1524 tty.main.c_cflag |= CS8; /* allow 8th bit on input */
1525 tty.main.c_cflag &= ~PARENB;/* Don't check parity */
1528 if (CONSOLE_TTY_DATA (con)->controlling_terminal)
1530 tty.main.c_cc[VINTR] =
1531 CONSOLE_QUIT_CHAR (con); /* C-g (usually) gives SIGINT */
1532 /* Set up C-g for both SIGQUIT and SIGINT.
1533 We don't know which we will get, but we handle both alike
1534 so which one it really gives us does not matter. */
1535 tty.main.c_cc[VQUIT] = CONSOLE_QUIT_CHAR (con);
1539 tty.main.c_cc[VINTR] = _POSIX_VDISABLE;
1540 tty.main.c_cc[VQUIT] = _POSIX_VDISABLE;
1542 tty.main.c_cc[VMIN] = 1; /* Input should wait for at
1544 tty.main.c_cc[VTIME] = 0; /* no matter how long that takes. */
1546 tty.main.c_cc[VSWTCH] = _POSIX_VDISABLE; /* Turn off shell layering use
1549 /* There was some conditionalizing here on (mips or TCATTR), but
1550 I think that's wrong. There was one report of C-y (DSUSP) not being
1551 disabled on HP9000s700 systems, and this might fix it. */
1553 tty.main.c_cc[VSUSP] = _POSIX_VDISABLE; /* Turn off mips handling of C-z. */
1556 tty.main.c_cc[V_DSUSP] = _POSIX_VDISABLE; /* Turn off mips handling of C-y. */
1557 #endif /* V_DSUSP */
1558 #ifdef VDSUSP /* Some systems have VDSUSP, some have V_DSUSP. */
1559 tty.main.c_cc[VDSUSP] = _POSIX_VDISABLE;
1562 tty.main.c_cc[VLNEXT] = _POSIX_VDISABLE;
1565 tty.main.c_cc[VREPRINT] = _POSIX_VDISABLE;
1566 #endif /* VREPRINT */
1568 tty.main.c_cc[VWERASE] = _POSIX_VDISABLE;
1569 #endif /* VWERASE */
1571 tty.main.c_cc[VDISCARD] = _POSIX_VDISABLE;
1572 #endif /* VDISCARD */
1574 tty.main.c_cc[VSTART] = _POSIX_VDISABLE;
1577 tty.main.c_cc[VSTRT] = _POSIX_VDISABLE; /* called VSTRT on some systems */
1580 tty.main.c_cc[VSTOP] = _POSIX_VDISABLE;
1582 #ifdef SET_LINE_DISCIPLINE
1583 /* Need to explicitly request TERMIODISC line discipline or
1584 Ultrix's termios does not work correctly. */
1585 tty.main.c_line = SET_LINE_DISCIPLINE;
1590 /* AIX enhanced edit loses NULs, so disable it. */
1591 tty.main.c_line = 0;
1592 tty.main.c_iflag &= ~ASCEDIT;
1594 tty.main.c_cc[VSTRT] = 255;
1595 tty.main.c_cc[VSTOP] = 255;
1596 tty.main.c_cc[VSUSP] = 255;
1597 tty.main.c_cc[VDSUSP] = 255;
1598 #endif /* IBMR2AIX */
1599 /* Also, PTY overloads NUL and BREAK.
1600 don't ignore break, but don't signal either, so it looks like NUL.
1601 This really serves a purpose only if running in an XTERM window
1602 or via TELNET or the like, but does no harm elsewhere. */
1603 tty.main.c_iflag &= ~IGNBRK;
1604 tty.main.c_iflag &= ~BRKINT;
1606 #else /* if not HAVE_TERMIO */
1607 #if !defined (WINDOWSNT)
1608 con->tty_erase_char = make_char (tty.main.sg_erase);
1609 tty.main.sg_flags &= ~(ECHO | CRMOD | XTABS);
1610 if (TTY_FLAGS (con).meta_key)
1611 tty.main.sg_flags |= ANYP;
1612 /* #### should we be using RAW mode here? */
1613 tty.main.sg_flags |= /* interrupt_input ? RAW : */ CBREAK;
1614 #endif /* not WINDOWSNT */
1615 #endif /* not HAVE_TERMIO */
1617 /* If going to use CBREAK mode, we must request C-g to interrupt
1618 and turn off start and stop chars, etc. If not going to use
1619 CBREAK mode, do this anyway so as to turn off local flow
1620 control for user coming over network on 4.2; in this case,
1621 only t_stopc and t_startc really matter. */
1624 /* Note: if not using CBREAK mode, it makes no difference how we
1626 tty.tchars = new_tchars;
1627 tty.tchars.t_intrc = CONSOLE_QUIT_CHAR (con);
1628 if (TTY_FLAGS (con).flow_control)
1630 tty.tchars.t_startc = '\021';
1631 tty.tchars.t_stopc = '\023';
1634 tty.lmode = LDECCTQ | LLITOUT | LPASS8 | LNOFLSH |
1635 CONSOLE_TTY_DATA (con)->old_tty.lmode;
1637 #if defined (ultrix) || defined (__bsdi__)
1638 /* Under Ultrix 4.2a, leaving this out doesn't seem to hurt
1639 anything, and leaving it in breaks the meta key. Go figure. */
1640 /* Turning off ONLCR is enough under BSD/386. Leave the general
1641 output post-processing flag alone since for some reason it
1642 doesn't get reset after XEmacs goes away. */
1643 tty.lmode &= ~LLITOUT;
1646 #endif /* HAVE_TCHARS */
1647 #endif /* not HAVE_TERMIO */
1650 tty.ltchars = new_ltchars;
1651 #endif /* HAVE_LTCHARS */
1653 EMACS_SET_TTY (input_fd, &tty, 0);
1655 /* This code added to insure that, if flow-control is not to be used,
1656 we have an unlocked terminal at the start. */
1659 if (!TTY_FLAGS (con).flow_control) ioctl (input_fd, TCXONC, 1);
1663 if (!TTY_FLAGS (con).flow_control) ioctl (input_fd, TIOCSTART, 0);
1667 #if defined (HAVE_TERMIOS) || defined (HPUX9)
1669 if (!TTY_FLAGS (con).flow_control) tcflow (input_fd, TCOON);
1676 /* IBM's HFT device usually thinks a ^J should be LF/CR.
1677 We need it to be only LF. This is the way that is
1681 if (ioctl (output_fd, HFTGETID, &tty) != -1)
1682 write (output_fd, "\033[20l", 5);
1687 #if 0 /* We do our own buffering with lstreams. */
1689 /* This symbol is defined on recent USG systems.
1690 Someone says without this call USG won't really buffer the file
1691 even with a call to setbuf. */
1692 setvbuf (CONSOLE_TTY_DATA (con)->outfd, (char *) _sobuf, _IOFBF, sizeof _sobuf);
1694 setbuf (CONSOLE_TTY_DATA (con)->outfd, (char *) _sobuf);
1697 set_tty_modes (con);
1700 #endif /* HAVE_TTY */
1703 init_one_device (struct device *d)
1706 if (DEVICE_TTY_P (d))
1707 tty_init_sys_modes_on_device (d);
1709 #if defined(SIGIO) && !defined(BROKEN_SIGIO)
1710 if (!DEVICE_STREAM_P (d))
1712 init_sigio_on_device (d);
1713 request_sigio_on_device (d);
1719 init_one_console (struct console *con)
1721 Lisp_Object devcons;
1723 CONSOLE_DEVICE_LOOP (devcons, con)
1725 struct device *d = XDEVICE (XCAR (devcons));
1727 init_one_device (d);
1732 reinit_initial_console (void)
1734 munge_process_groups ();
1735 if (CONSOLEP (Vcontrolling_terminal) &&
1736 CONSOLE_LIVE_P (XCONSOLE (Vcontrolling_terminal)))
1737 init_one_console (XCONSOLE (Vcontrolling_terminal));
1741 /* ------------------------------------------------------ */
1742 /* Other TTY functions */
1743 /* ------------------------------------------------------ */
1747 #if 0 /* not currently used */
1749 /* Return nonzero if safe to use tabs in output.
1750 At the time this is called, init_sys_modes has not been done yet. */
1753 tabs_safe_p (struct device *d)
1756 if (DEVICE_TTY_P (d))
1758 struct emacs_tty tty;
1760 EMACS_GET_TTY (DEVICE_INFD (d), &tty);
1761 return EMACS_TTY_TABS_OK (&tty);
1769 /* Get terminal size from system.
1770 Store number of lines into *heightp and width into *widthp.
1771 If zero or a negative number is stored, the value is not valid. */
1774 get_tty_device_size (struct device *d, int *widthp, int *heightp)
1776 int input_fd = DEVICE_INFD (d);
1778 assert (DEVICE_TTY_P (d));
1783 struct winsize size;
1785 if (ioctl (input_fd, TIOCGWINSZ, &size) == -1)
1786 *widthp = *heightp = 0;
1789 *widthp = size.ws_col;
1790 *heightp = size.ws_row;
1793 #elif defined TIOCGSIZE
1795 /* SunOS - style. */
1796 struct ttysize size;
1798 if (ioctl (input_fd, TIOCGSIZE, &size) == -1)
1799 *widthp = *heightp = 0;
1802 *widthp = size.ts_cols;
1803 *heightp = size.ts_lines;
1806 #else /* system doesn't know size */
1811 #endif /* not !TIOCGWINSZ */
1814 #endif /* HAVE_TTY */
1817 /* ------------------------------------------------------ */
1818 /* Is device 8 bit ? */
1819 /* ------------------------------------------------------ */
1824 eight_bit_tty (struct device *d)
1830 assert (DEVICE_TTY_P (d));
1831 input_fd = DEVICE_INFD (d);
1833 EMACS_GET_TTY (input_fd, &s);
1835 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
1836 eight_bit = (s.main.c_cflag & CSIZE) == CS8;
1838 eight_bit = 0; /* I don't know how to do it */
1843 #endif /* HAVE_TTY */
1846 /* ------------------------------------------------------ */
1847 /* Resetting a device */
1848 /* ------------------------------------------------------ */
1852 /* Prepare the terminal for exiting Emacs; move the cursor to the
1853 bottom of the frame, turn off interrupt-driven I/O, etc. */
1855 tty_reset_sys_modes_on_device (struct device *d)
1857 int input_fd, output_fd;
1858 struct console *con = XCONSOLE (DEVICE_CONSOLE (d));
1860 input_fd = CONSOLE_TTY_DATA (con)->infd;
1861 output_fd = CONSOLE_TTY_DATA (con)->outfd;
1863 #if defined (IBMR2AIX) && defined (AIXHFT)
1865 /* HFT consoles normally use ^J as a LF/CR. We forced it to
1866 do the LF only. Now, we need to reset it. */
1869 if (ioctl (output_fd, HFTGETID, &tty) != -1)
1870 write (output_fd, "\033[20h", 5);
1874 tty_redisplay_shutdown (con);
1875 /* reset_tty_modes() flushes the connection at its end. */
1876 reset_tty_modes (con);
1879 /* Avoid possible loss of output when changing terminal modes. */
1883 while (EMACS_SET_TTY (input_fd, &CONSOLE_TTY_DATA (con)->old_tty, 0)
1884 < 0 && errno == EINTR)
1887 #ifdef SET_LINE_DISCIPLINE
1888 /* Ultrix's termios *ignores* any line discipline except TERMIODISC.
1889 A different old line discipline is therefore not restored, yet.
1890 Restore the old line discipline by hand. */
1891 ioctl (input_fd, TIOCSETD, &old_tty.main.c_line);
1900 #endif /* HAVE_TTY */
1903 reset_one_device (struct device *d)
1906 if (DEVICE_TTY_P (d))
1907 tty_reset_sys_modes_on_device (d);
1910 if (DEVICE_STREAM_P (d))
1911 fflush (CONSOLE_STREAM_DATA (XCONSOLE (DEVICE_CONSOLE (d)))->out);
1912 #if defined(SIGIO) && !defined(BROKEN_SIGIO)
1913 if (!DEVICE_STREAM_P (d))
1915 unrequest_sigio_on_device (d);
1916 reset_sigio_on_device (d);
1922 reset_one_console (struct console *con)
1924 /* Note: this can be called during GC. */
1925 Lisp_Object devcons;
1927 CONSOLE_DEVICE_LOOP (devcons, con)
1929 struct device *d = XDEVICE (XCAR (devcons));
1931 reset_one_device (d);
1936 reset_all_consoles (void)
1938 /* Note: this can be called during GC. */
1939 Lisp_Object concons;
1941 CONSOLE_LOOP (concons)
1943 struct console *con = XCONSOLE (XCAR (concons));
1945 reset_one_console (con);
1948 unmunge_process_groups ();
1952 reset_initial_console (void)
1954 if (CONSOLEP (Vcontrolling_terminal) &&
1955 CONSOLE_LIVE_P (XCONSOLE (Vcontrolling_terminal)))
1956 reset_one_console (XCONSOLE (Vcontrolling_terminal));
1957 unmunge_process_groups ();
1961 /* ------------------------------------------------------ */
1962 /* extra TTY stuff under AIX */
1963 /* ------------------------------------------------------ */
1967 /* Called from init_sys_modes. */
1969 hft_init (struct console *con)
1974 assert (CONSOLE_TTY_P (con));
1975 input_fd = CONSOLE_TTY_DATA (con)->infd;
1977 /* If we're not on an HFT we shouldn't do any of this. We determine
1978 if we are on an HFT by trying to get an HFT error code. If this
1979 call fails, we're not on an HFT. */
1981 if (ioctl (input_fd, HFQERROR, &junk) < 0)
1983 #else /* not IBMR2AIX */
1984 if (ioctl (input_fd, HFQEIO, 0) < 0)
1986 #endif /* not IBMR2AIX */
1988 /* On AIX the default hft keyboard mapping uses backspace rather than delete
1989 as the rubout key's ASCII code. Here this is changed. The bug is that
1990 there's no way to determine the old mapping, so in reset_one_console
1991 we need to assume that the normal map had been present. Of course, this
1992 code also doesn't help if on a terminal emulator which doesn't understand
1996 struct hfkeymap keymap;
1998 buf.hf_bufp = (char *)&keymap;
1999 buf.hf_buflen = sizeof (keymap);
2000 keymap.hf_nkeys = 2;
2001 keymap.hfkey[0].hf_kpos = 15;
2002 keymap.hfkey[0].hf_kstate = HFMAPCHAR | HFSHFNONE;
2004 keymap.hfkey[0].hf_keyidh = '<';
2005 #else /* not IBMR2AIX */
2006 keymap.hfkey[0].hf_page = '<';
2007 #endif /* not IBMR2AIX */
2008 keymap.hfkey[0].hf_char = 127;
2009 keymap.hfkey[1].hf_kpos = 15;
2010 keymap.hfkey[1].hf_kstate = HFMAPCHAR | HFSHFSHFT;
2012 keymap.hfkey[1].hf_keyidh = '<';
2013 #else /* not IBMR2AIX */
2014 keymap.hfkey[1].hf_page = '<';
2015 #endif /* not IBMR2AIX */
2016 keymap.hfkey[1].hf_char = 127;
2017 hftctl (input_fd, HFSKBD, &buf);
2019 /* #### Should probably set a console TTY flag here. */
2021 /* The HFT system on AIX doesn't optimize for scrolling, so it's really ugly
2023 line_ins_del_ok = char_ins_del_ok = 0;
2027 /* Reset the rubout key to backspace. */
2030 hft_reset (struct console *con)
2033 struct hfkeymap keymap;
2037 assert (CONSOLE_TTY_P (con));
2038 input_fd = CONSOLE_TTY_DATA (con)->infd;
2041 if (ioctl (input_fd, HFQERROR, &junk) < 0)
2043 #else /* not IBMR2AIX */
2044 if (ioctl (input_fd, HFQEIO, 0) < 0)
2046 #endif /* not IBMR2AIX */
2048 buf.hf_bufp = (char *)&keymap;
2049 buf.hf_buflen = sizeof (keymap);
2050 keymap.hf_nkeys = 2;
2051 keymap.hfkey[0].hf_kpos = 15;
2052 keymap.hfkey[0].hf_kstate = HFMAPCHAR | HFSHFNONE;
2054 keymap.hfkey[0].hf_keyidh = '<';
2055 #else /* not IBMR2AIX */
2056 keymap.hfkey[0].hf_page = '<';
2057 #endif /* not IBMR2AIX */
2058 keymap.hfkey[0].hf_char = 8;
2059 keymap.hfkey[1].hf_kpos = 15;
2060 keymap.hfkey[1].hf_kstate = HFMAPCHAR | HFSHFSHFT;
2062 keymap.hfkey[1].hf_keyidh = '<';
2063 #else /* not IBMR2AIX */
2064 keymap.hfkey[1].hf_page = '<';
2065 #endif /* not IBMR2AIX */
2066 keymap.hfkey[1].hf_char = 8;
2067 hftctl (input_fd, HFSKBD, &buf);
2073 /************************************************************************/
2074 /* limits of text/data segments */
2075 /************************************************************************/
2081 #ifndef SYSTEM_MALLOC
2088 /* Some systems that cannot dump also cannot implement these. */
2091 * Return the address of the start of the text segment prior to
2092 * doing an unexec. After unexec the return value is undefined.
2093 * See crt0.c for further explanation and _start.
2098 extern "C" int _start ();
2100 extern int _start ();
2103 #ifndef HAVE_TEXT_START
2105 start_of_text (void)
2108 return ((char *) TEXT_START);
2112 return ((char *) csrt);
2113 #else /* not GOULD */
2114 return ((char *) _start);
2116 #endif /* TEXT_START */
2118 #endif /* not HAVE_TEXT_START */
2121 * Return the address of the start of the data segment prior to
2122 * doing an unexec. After unexec the return value is undefined.
2123 * See crt0.c for further information and definition of data_start.
2125 * Apparently, on BSD systems this is etext at startup. On
2126 * USG systems (swapping) this is highly mmu dependent and
2127 * is also dependent on whether or not the program is running
2128 * with shared text. Generally there is a (possibly large)
2129 * gap between end of text and start of data with shared text.
2131 * On Uniplus+ systems with shared text, data starts at a
2132 * fixed address. Each port (from a given oem) is generally
2133 * different, and the specific value of the start of data can
2134 * be obtained via the UniPlus+ specific "uvar" system call,
2135 * however the method outlined in crt0.c seems to be more portable.
2137 * Probably what will have to happen when a USG unexec is available,
2138 * at least on UniPlus, is temacs will have to be made unshared so
2139 * that text and data are contiguous. Then once loadup is complete,
2140 * unexec will produce a shared executable where the data can be
2141 * at the normal shared text boundary and the startofdata variable
2142 * will be patched by unexec to the correct value.
2146 #ifdef ORDINARY_LINK
2147 extern char **environ;
2151 start_of_data (void)
2154 return ((char *) DATA_START);
2156 #ifdef ORDINARY_LINK
2158 * This is a hack. Since we're not linking crt0.c or pre_crt0.c,
2159 * data_start isn't defined. We take the address of environ, which
2160 * is known to live at or near the start of the system crt0.c, and
2161 * we don't sweat the handful of bytes that might lose.
2164 extern char* static_heap_base;
2166 return static_heap_base;
2168 return((char *) &environ);
2170 extern int data_start;
2171 return ((char *) &data_start);
2172 #endif /* ORDINARY_LINK */
2173 #endif /* DATA_START */
2175 #endif /* NEED_STARTS (not CANNOT_DUMP or not SYSTEM_MALLOC) */
2178 /* Some systems that cannot dump also cannot implement these. */
2181 * Return the address of the end of the text segment prior to
2182 * doing an unexec. After unexec the return value is undefined.
2189 return ((char *) TEXT_END);
2192 return ((char *) &etext);
2197 * Return the address of the end of the data segment prior to
2198 * doing an unexec. After unexec the return value is undefined.
2205 return ((char *) DATA_END);
2208 return ((char *) &edata);
2212 #endif /* not CANNOT_DUMP */
2215 /************************************************************************/
2216 /* get the system name */
2217 /************************************************************************/
2219 /* init_system_name sets up the string for the Lisp function
2220 system-name to return. */
2222 extern Lisp_Object Vsystem_name;
2225 # include <sys/socket.h>
2227 #endif /* HAVE_SOCKETS */
2230 init_system_name (void)
2232 #if defined (WINDOWSNT)
2233 char hostname [MAX_COMPUTERNAME_LENGTH + 1];
2234 size_t size = sizeof(hostname);
2235 GetComputerName (hostname, &size);
2236 Vsystem_name = build_string (hostname);
2237 #elif !defined (HAVE_GETHOSTNAME)
2240 Vsystem_name = build_string (uts.nodename);
2241 #else /* HAVE_GETHOSTNAME */
2242 unsigned int hostname_size = 256;
2243 char *hostname = (char *) alloca (hostname_size);
2245 /* Try to get the host name; if the buffer is too short, try
2246 again. Apparently, the only indication gethostname gives of
2247 whether the buffer was large enough is the presence or absence
2248 of a '\0' in the string. Eech. */
2251 gethostname (hostname, hostname_size - 1);
2252 hostname[hostname_size - 1] = '\0';
2254 /* Was the buffer large enough for the '\0'? */
2255 if (strlen (hostname) < (size_t) (hostname_size - 1))
2258 hostname_size <<= 1;
2259 hostname = (char *) alloca (hostname_size);
2261 # if defined( HAVE_SOCKETS) && !defined(BROKEN_CYGWIN)
2262 /* Turn the hostname into the official, fully-qualified hostname.
2263 Don't do this if we're going to dump; this can confuse system
2264 libraries on some machines and make the dumped emacs core dump. */
2265 # ifndef CANNOT_DUMP
2267 # endif /* not CANNOT_DUMP */
2268 if (!strchr (hostname, '.'))
2270 struct hostent *hp = NULL;
2273 for (count = 0; count < 10; count++)
2277 /* Some systems can't handle SIGALARM/SIGIO in gethostbyname(). */
2279 hp = gethostbyname (hostname);
2280 start_interrupts ();
2282 if (! (hp == 0 && h_errno == TRY_AGAIN))
2284 Fsleep_for (make_int (1));
2289 CONST char *fqdn = (CONST char *) hp->h_name;
2291 if (!strchr (fqdn, '.'))
2293 /* We still don't have a fully qualified domain name.
2294 Try to find one in the list of alternate names */
2295 char **alias = hp->h_aliases;
2296 while (*alias && !strchr (*alias, '.'))
2301 hostname = (char *) alloca (strlen (fqdn) + 1);
2302 strcpy (hostname, fqdn);
2305 # endif /* HAVE_SOCKETS */
2306 Vsystem_name = build_string (hostname);
2307 #endif /* HAVE_GETHOSTNAME */
2312 for (i = 0, p = XSTRING_DATA (Vsystem_name);
2313 i < XSTRING_LENGTH (Vsystem_name);
2316 if (*p == ' ' || *p == '\t')
2323 /************************************************************************/
2324 /* Emulation of select() */
2325 /************************************************************************/
2329 ERROR: XEmacs requires a working select().
2331 #endif /* not HAVE_SELECT */
2334 /************************************************************************/
2335 /* Emulation of signal stuff */
2336 /************************************************************************/
2338 /* BSD 4.1 crap deleted. 4.2 was released in 1983, for God's sake! I
2339 can't imagine that anyone is actually running that OS any more.
2340 You can't use X under it (I think) because there's no select().
2341 Anyway, the signal stuff has all been changed. If someone wants to
2342 get this stuff working again, look in the FSF Emacs sources. */
2344 /* POSIX signals support - DJB */
2346 #ifdef HAVE_SIGPROCMASK
2348 /* #### Is there any reason this is static global rather than local? */
2349 static struct sigaction new_action, old_action;
2352 sys_do_signal (int signal_number, signal_handler_t action)
2356 /* XEmacs works better if system calls are *not* restarted.
2357 This allows C-g to interrupt reads and writes, on most systems.
2359 #### Another possibility is to just longjmp() out of the signal
2360 handler. According to W.R. Stevens, this should be OK on all
2361 systems. However, I don't want to deal with the potential
2362 evil ramifications of this at this point. */
2365 /* This gets us restartable system calls for efficiency.
2366 The "else" code will work as well. */
2367 return (berk_signal (signal_number, action));
2369 sigemptyset (&new_action.sa_mask);
2370 new_action.sa_handler = action;
2371 #if defined (SA_RESTART)
2372 /* Emacs mostly works better with restartable system services. If this
2373 * flag exists, we probably want to turn it on here.
2375 new_action.sa_flags = SA_RESTART;
2377 new_action.sa_flags = 0;
2379 sigaction (signal_number, &new_action, &old_action);
2380 return (old_action.sa_handler);
2385 sigemptyset (&new_action.sa_mask);
2386 new_action.sa_handler = action;
2387 #if defined (SA_INTERRUPT) /* don't restart system calls, under SunOS */
2388 new_action.sa_flags = SA_INTERRUPT;
2390 new_action.sa_flags = 0;
2392 sigaction (signal_number, &new_action, &old_action);
2393 return (signal_handler_t) (old_action.sa_handler);
2398 #elif defined (HAVE_SIGBLOCK)
2400 /* We use sigvec() rather than signal() if we have it, because
2401 it lets us specify interruptible system calls. */
2403 sys_do_signal (int signal_number, signal_handler_t action)
2405 struct sigvec vec, ovec;
2407 vec.sv_handler = action;
2409 #ifdef SV_INTERRUPT /* don't restart system calls */
2410 vec.sv_flags = SV_INTERRUPT;
2415 sigvec (signal_number, &vec, &ovec);
2417 return (ovec.sv_handler);
2420 #endif /* HAVE_SIGBLOCK (HAVE_SIGPROCMASK) */
2423 /************************************************************************/
2424 /* Emulation of strerror() and errno support */
2425 /************************************************************************/
2427 #ifndef HAVE_STRERROR
2429 #if !defined(NeXT) && !defined(__alpha) && !defined(MACH) && !defined(LINUX) && !defined(IRIX) && !defined(__NetBSD__)
2430 /* Linux added here by Raymond L. Toy <toy@alydar.crd.ge.com> for XEmacs. */
2431 /* Irix added here by gparker@sni-usa.com for XEmacs. */
2432 /* NetBSD added here by James R Grinter <jrg@doc.ic.ac.uk> for XEmacs */
2433 extern CONST char *sys_errlist[];
2434 extern int sys_nerr;
2438 extern char *sys_errlist[];
2439 extern int sys_nerr;
2444 strerror (int errnum)
2446 if (errnum >= 0 && errnum < sys_nerr)
2447 return sys_errlist[errnum];
2448 return ((CONST char *) GETTEXT ("Unknown error"));
2451 #endif /* ! HAVE_STRERROR */
2456 unsigned long oscode; /* Win32 error */
2457 int errnocode; /* unix errno */
2460 static struct errentry errtable[] = {
2461 { ERROR_INVALID_FUNCTION, EINVAL }, /* 1 */
2462 { ERROR_FILE_NOT_FOUND, ENOENT }, /* 2 */
2463 { ERROR_PATH_NOT_FOUND, ENOENT }, /* 3 */
2464 { ERROR_TOO_MANY_OPEN_FILES, EMFILE }, /* 4 */
2465 { ERROR_ACCESS_DENIED, EACCES }, /* 5 */
2466 { ERROR_INVALID_HANDLE, EBADF }, /* 6 */
2467 { ERROR_ARENA_TRASHED, ENOMEM }, /* 7 */
2468 { ERROR_NOT_ENOUGH_MEMORY, ENOMEM }, /* 8 */
2469 { ERROR_INVALID_BLOCK, ENOMEM }, /* 9 */
2470 { ERROR_BAD_ENVIRONMENT, E2BIG }, /* 10 */
2471 { ERROR_BAD_FORMAT, ENOEXEC }, /* 11 */
2472 { ERROR_INVALID_ACCESS, EINVAL }, /* 12 */
2473 { ERROR_INVALID_DATA, EINVAL }, /* 13 */
2474 { ERROR_INVALID_DRIVE, ENOENT }, /* 15 */
2475 { ERROR_CURRENT_DIRECTORY, EACCES }, /* 16 */
2476 { ERROR_NOT_SAME_DEVICE, EXDEV }, /* 17 */
2477 { ERROR_NO_MORE_FILES, ENOENT }, /* 18 */
2478 { ERROR_LOCK_VIOLATION, EACCES }, /* 33 */
2479 { ERROR_BAD_NETPATH, ENOENT }, /* 53 */
2480 { ERROR_NETWORK_ACCESS_DENIED, EACCES }, /* 65 */
2481 { ERROR_BAD_NET_NAME, ENOENT }, /* 67 */
2482 { ERROR_FILE_EXISTS, EEXIST }, /* 80 */
2483 { ERROR_CANNOT_MAKE, EACCES }, /* 82 */
2484 { ERROR_FAIL_I24, EACCES }, /* 83 */
2485 { ERROR_INVALID_PARAMETER, EINVAL }, /* 87 */
2486 { ERROR_NO_PROC_SLOTS, EAGAIN }, /* 89 */
2487 { ERROR_DRIVE_LOCKED, EACCES }, /* 108 */
2488 { ERROR_BROKEN_PIPE, EPIPE }, /* 109 */
2489 { ERROR_DISK_FULL, ENOSPC }, /* 112 */
2490 { ERROR_INVALID_TARGET_HANDLE, EBADF }, /* 114 */
2491 { ERROR_INVALID_HANDLE, EINVAL }, /* 124 */
2492 { ERROR_WAIT_NO_CHILDREN, ECHILD }, /* 128 */
2493 { ERROR_CHILD_NOT_COMPLETE, ECHILD }, /* 129 */
2494 { ERROR_DIRECT_ACCESS_HANDLE, EBADF }, /* 130 */
2495 { ERROR_NEGATIVE_SEEK, EINVAL }, /* 131 */
2496 { ERROR_SEEK_ON_DEVICE, EACCES }, /* 132 */
2497 { ERROR_DIR_NOT_EMPTY, ENOTEMPTY }, /* 145 */
2498 { ERROR_NOT_LOCKED, EACCES }, /* 158 */
2499 { ERROR_BAD_PATHNAME, ENOENT }, /* 161 */
2500 { ERROR_MAX_THRDS_REACHED, EAGAIN }, /* 164 */
2501 { ERROR_LOCK_FAILED, EACCES }, /* 167 */
2502 { ERROR_ALREADY_EXISTS, EEXIST }, /* 183 */
2503 { ERROR_FILENAME_EXCED_RANGE, ENOENT }, /* 206 */
2504 { ERROR_NESTING_NOT_ALLOWED, EAGAIN }, /* 215 */
2505 { ERROR_NOT_ENOUGH_QUOTA, ENOMEM } /* 1816 */
2508 /* The following two constants must be the minimum and maximum
2509 values in the (contiguous) range of Exec Failure errors. */
2510 #define MIN_EXEC_ERROR ERROR_INVALID_STARTING_CODESEG
2511 #define MAX_EXEC_ERROR ERROR_INFLOOP_IN_RELOC_CHAIN
2513 /* These are the low and high value in the range of errors that are
2514 access violations */
2515 #define MIN_EACCES_RANGE ERROR_WRITE_PROTECT
2516 #define MAX_EACCES_RANGE ERROR_SHARING_BUFFER_EXCEEDED
2519 mswindows_set_errno (unsigned long win32_error)
2523 /* check the table for the OS error code */
2524 for (i = 0; i < sizeof(errtable)/sizeof(errtable[0]); ++i)
2526 if (win32_error == errtable[i].oscode)
2528 errno = errtable[i].errnocode;
2533 /* The error code wasn't in the table. We check for a range of
2534 * EACCES errors or exec failure errors (ENOEXEC). Otherwise EINVAL is
2536 if (win32_error >= MIN_EACCES_RANGE && win32_error <= MAX_EACCES_RANGE)
2538 else if (win32_error >= MIN_EXEC_ERROR && win32_error <= MAX_EXEC_ERROR)
2545 mswindows_set_last_errno (void)
2547 mswindows_set_errno (GetLastError ());
2550 #endif /* WINDOWSNT */
2553 /************************************************************************/
2554 /* Encapsulations of system calls */
2555 /************************************************************************/
2557 #define PATHNAME_CONVERT_OUT(path) \
2558 GET_C_CHARPTR_EXT_FILENAME_DATA_ALLOCA ((CONST Bufbyte *) path, path)
2560 /***************** low-level calls ****************/
2563 * On USG systems the system calls are INTERRUPTIBLE by signals
2564 * that the user program has elected to catch. Thus the system call
2565 * must be retried in these cases. To handle this without massive
2566 * changes in the source code, we remap the standard system call names
2567 * to names for our own functions in sysdep.c that do the system call
2568 * with retries. Actually, for portability reasons, it is good
2569 * programming practice, as this example shows, to limit all actual
2570 * system calls to a single occurrence in the source. Sure, this
2571 * adds an extra level of function call overhead but it is almost
2572 * always negligible. Fred Fish, Unisoft Systems Inc.
2575 /* Ben sez: read Dick Gabriel's essay about the Worse Is Better
2576 approach to programming and its connection to the silly
2577 interruptible-system-call business. To find it, look at
2578 Jamie's home page (http://www.netscape.com/people/jwz). */
2580 #ifdef ENCAPSULATE_OPEN
2582 sys_open (CONST char *path, int oflag, ...)
2587 va_start (ap, oflag);
2588 mode = va_arg (ap, int);
2591 PATHNAME_CONVERT_OUT (path);
2592 #if defined (WINDOWSNT)
2593 /* Make all handles non-inheritable */
2594 return open (path, oflag | _O_NOINHERIT, mode);
2595 #elif defined (INTERRUPTIBLE_OPEN)
2598 while ((rtnval = open (path, oflag, mode)) == -1
2599 && (errno == EINTR))
2604 return open (path, oflag, mode);
2607 #endif /* ENCAPSULATE_OPEN */
2609 /* Like sys_open, only when open() is interrupted by EINTR, check for
2610 QUIT. This allows the callers of this function to be interrupted
2611 with C-g when, say, reading from named pipes. However, this should
2612 be used with caution, as it can GC.
2614 This function will not function as expected on systems where open()
2615 is not interrupted by C-g. However, the worst that can happen is
2616 the fallback to simple open(). */
2618 interruptible_open (CONST char *path, int oflag, int mode)
2620 /* This function can GC */
2621 size_t len = strlen (path);
2622 char *nonreloc = (char *) alloca (len + 1);
2624 /* Must copy PATH, because it might be the data of a Lisp_String,
2625 which could be relocated by GC when checking for QUIT. */
2626 memcpy (nonreloc, path, len + 1);
2628 PATHNAME_CONVERT_OUT (nonreloc);
2632 int rtnval = open (nonreloc, oflag, mode);
2633 if (!(rtnval == -1 && errno == EINTR))
2635 /* open() was interrupted. Was QUIT responsible? */
2640 #ifdef ENCAPSULATE_CLOSE
2644 #ifdef INTERRUPTIBLE_CLOSE
2646 REGISTER int rtnval;
2648 while ((rtnval = close (fd)) == -1
2649 && (errno == EINTR))
2652 /* If close is interrupted SunOS 4.1 may or may not have closed the
2653 file descriptor. If it did the second close will fail with
2654 errno = EBADF. That means we have succeeded. */
2655 if (rtnval == -1 && did_retry && errno == EBADF)
2663 #endif /* ENCAPSULATE_CLOSE */
2666 sys_read_1 (int fildes, void *buf, size_t nbyte, int allow_quit)
2670 /* No harm in looping regardless of the INTERRUPTIBLE_IO setting. */
2671 while ((rtnval = read (fildes, buf, nbyte)) == -1
2672 && (errno == EINTR))
2680 #ifdef ENCAPSULATE_READ
2682 sys_read (int fildes, void *buf, size_t nbyte)
2684 return sys_read_1 (fildes, buf, nbyte, 0);
2686 #endif /* ENCAPSULATE_READ */
2689 sys_write_1 (int fildes, CONST void *buf, size_t nbyte, int allow_quit)
2692 int bytes_written = 0;
2693 CONST char *b = (CONST char *) buf;
2695 /* No harm in looping regardless of the INTERRUPTIBLE_IO setting. */
2698 rtnval = write (fildes, b, nbyte);
2708 return (bytes_written ? bytes_written : -1);
2712 bytes_written += rtnval;
2714 return (bytes_written);
2717 #ifdef ENCAPSULATE_WRITE
2719 sys_write (int fildes, CONST void *buf, size_t nbyte)
2721 return sys_write_1 (fildes, buf, nbyte, 0);
2723 #endif /* ENCAPSULATE_WRITE */
2726 /**************** stdio calls ****************/
2728 /* There is at least some evidence that the stdio calls are interruptible
2729 just like the normal system calls, at least on some systems. In any
2730 case, it doesn't hurt to encapsulate them. */
2732 /* #### Should also encapsulate fflush().
2733 #### Should conceivably encapsulate getchar() etc. What a pain! */
2735 #ifdef ENCAPSULATE_FOPEN
2737 sys_fopen (CONST char *path, CONST char *type)
2739 PATHNAME_CONVERT_OUT (path);
2740 #if defined (WINDOWSNT)
2744 const char * type_save = type;
2746 /* Force all file handles to be non-inheritable. This is necessary to
2747 ensure child processes don't unwittingly inherit handles that might
2748 prevent future file access. */
2752 else if (type[0] == 'w' || type[0] == 'a')
2753 oflag = O_WRONLY | O_CREAT | O_TRUNC;
2757 /* Only do simplistic option parsing. */
2761 oflag &= ~(O_RDONLY | O_WRONLY);
2764 else if (type[0] == 'b')
2769 else if (type[0] == 't')
2776 fd = open (path, oflag | _O_NOINHERIT, 0644);
2780 return _fdopen (fd, type_save);
2782 #elif defined (INTERRUPTIBLE_OPEN)
2785 while (!(rtnval = fopen (path, type)) && (errno == EINTR))
2790 return fopen (path, type);
2793 #endif /* ENCAPSULATE_FOPEN */
2796 #ifdef ENCAPSULATE_FCLOSE
2798 sys_fclose (FILE *stream)
2800 #ifdef INTERRUPTIBLE_CLOSE
2803 while ((rtnval = fclose (stream)) == EOF
2804 && (errno == EINTR))
2808 return fclose (stream);
2811 #endif /* ENCAPSULATE_FCLOSE */
2814 #ifdef ENCAPSULATE_FREAD
2816 sys_fread (void *ptr, size_t size, size_t nitem, FILE *stream)
2818 #ifdef INTERRUPTIBLE_IO
2820 size_t items_read = 0;
2821 char *b = (char *) ptr;
2825 rtnval = fread (b, size, nitem, stream);
2828 if (ferror (stream) && errno == EINTR)
2835 items_read += rtnval;
2837 return (items_read);
2839 return fread (ptr, size, nitem, stream);
2842 #endif /* ENCAPSULATE_FREAD */
2845 #ifdef ENCAPSULATE_FWRITE
2847 sys_fwrite (CONST void *ptr, size_t size, size_t nitem, FILE *stream)
2849 #ifdef INTERRUPTIBLE_IO
2851 size_t items_written = 0;
2852 CONST char *b = (CONST char *) ptr;
2856 rtnval = fwrite (b, size, nitem, stream);
2859 if (ferror (stream) && errno == EINTR)
2862 return items_written;
2866 items_written += rtnval;
2868 return (items_written);
2870 return fwrite (ptr, size, nitem, stream);
2873 #endif /* ENCAPSULATE_FWRITE */
2876 /********************* directory calls *******************/
2878 #ifdef ENCAPSULATE_CHDIR
2880 sys_chdir (CONST char *path)
2882 PATHNAME_CONVERT_OUT (path);
2883 return chdir (path);
2885 #endif /* ENCAPSULATE_CHDIR */
2888 #ifdef ENCAPSULATE_MKDIR
2890 sys_mkdir (CONST char *path, mode_t mode)
2892 PATHNAME_CONVERT_OUT (path);
2894 return mkdir (path);
2896 return mkdir (path, mode);
2899 #endif /* ENCAPSULATE_MKDIR */
2902 #ifdef ENCAPSULATE_OPENDIR
2904 sys_opendir (CONST char *filename)
2907 PATHNAME_CONVERT_OUT (filename);
2909 while (!(rtnval = opendir (filename))
2910 && (errno == EINTR))
2914 #endif /* ENCAPSULATE_OPENDIR */
2917 #ifdef ENCAPSULATE_READDIR
2919 sys_readdir (DIR *dirp)
2923 /* Apparently setting errno is necessary on some systems?
2924 Maybe readdir() doesn't always set errno ?! */
2925 while (!(errno = 0, rtnval = readdir (dirp))
2926 && (errno == EINTR))
2931 if (rtnval == NULL) /* End of directory */
2934 Extcount external_len;
2935 int ascii_filename_p = 1;
2936 CONST Extbyte * CONST external_name = (CONST Extbyte *) rtnval->d_name;
2938 /* Optimize for the common all-ASCII case, computing len en passant */
2939 for (external_len = 0; external_name[external_len] ; external_len++)
2941 if (!BYTE_ASCII_P (external_name[external_len]))
2942 ascii_filename_p = 0;
2944 if (ascii_filename_p)
2947 { /* Non-ASCII filename */
2948 static Bufbyte_dynarr *internal_DIRENTRY;
2949 CONST Bufbyte *internal_name;
2950 Bytecount internal_len;
2951 if (!internal_DIRENTRY)
2952 internal_DIRENTRY = Dynarr_new (Bufbyte);
2954 Dynarr_reset (internal_DIRENTRY);
2956 Dynarr_add_many (internal_DIRENTRY, (Bufbyte *) rtnval,
2957 offsetof (DIRENTRY, d_name));
2960 convert_from_external_format (external_name, external_len,
2961 &internal_len, FORMAT_FILENAME);
2963 Dynarr_add_many (internal_DIRENTRY, internal_name, internal_len);
2964 Dynarr_add (internal_DIRENTRY, 0); /* zero-terminate */
2965 return (DIRENTRY *) Dynarr_atp (internal_DIRENTRY, 0);
2970 #endif /* ENCAPSULATE_READDIR */
2973 #ifdef ENCAPSULATE_CLOSEDIR
2975 sys_closedir (DIR *dirp)
2979 while ((rtnval = closedir (dirp)) == -1
2980 && (errno == EINTR))
2984 #endif /* ENCAPSULATE_CLOSEDIR */
2987 #ifdef ENCAPSULATE_RMDIR
2989 sys_rmdir (CONST char *path)
2991 PATHNAME_CONVERT_OUT (path);
2992 return rmdir (path);
2994 #endif /* ENCAPSULATE_RMDIR */
2997 /***************** file-information calls ******************/
2999 #ifdef ENCAPSULATE_ACCESS
3001 sys_access (CONST char *path, int mode)
3003 PATHNAME_CONVERT_OUT (path);
3004 return access (path, mode);
3006 #endif /* ENCAPSULATE_ACCESS */
3010 #ifdef ENCAPSULATE_EACCESS
3012 sys_eaccess (CONST char *path, int mode)
3014 PATHNAME_CONVERT_OUT (path);
3015 return eaccess (path, mode);
3017 #endif /* ENCAPSULATE_EACCESS */
3018 #endif /* HAVE_EACCESS */
3021 #ifdef ENCAPSULATE_LSTAT
3023 sys_lstat (CONST char *path, struct stat *buf)
3025 PATHNAME_CONVERT_OUT (path);
3026 return lstat (path, buf);
3028 #endif /* ENCAPSULATE_LSTAT */
3031 #ifdef ENCAPSULATE_READLINK
3033 sys_readlink (CONST char *path, char *buf, size_t bufsiz)
3035 PATHNAME_CONVERT_OUT (path);
3036 /* #### currently we don't do conversions on the incoming data */
3037 return readlink (path, buf, bufsiz);
3039 #endif /* ENCAPSULATE_READLINK */
3042 #ifdef ENCAPSULATE_STAT
3044 sys_stat (CONST char *path, struct stat *buf)
3046 PATHNAME_CONVERT_OUT (path);
3047 return stat (path, buf);
3049 #endif /* ENCAPSULATE_STAT */
3052 /****************** file-manipulation calls *****************/
3054 #ifdef ENCAPSULATE_CHMOD
3056 sys_chmod (CONST char *path, mode_t mode)
3058 PATHNAME_CONVERT_OUT (path);
3059 return chmod (path, mode);
3061 #endif /* ENCAPSULATE_CHMOD */
3064 #ifdef ENCAPSULATE_CREAT
3066 sys_creat (CONST char *path, mode_t mode)
3068 PATHNAME_CONVERT_OUT (path);
3069 return creat (path, mode);
3071 #endif /* ENCAPSULATE_CREAT */
3074 #ifdef ENCAPSULATE_LINK
3076 sys_link (CONST char *existing, CONST char *new)
3078 PATHNAME_CONVERT_OUT (existing);
3079 PATHNAME_CONVERT_OUT (new);
3080 return link (existing, new);
3082 #endif /* ENCAPSULATE_LINK */
3085 #ifdef ENCAPSULATE_RENAME
3087 sys_rename (CONST char *old, CONST char *new)
3089 PATHNAME_CONVERT_OUT (old);
3090 PATHNAME_CONVERT_OUT (new);
3092 /* Windows rename fails if NEW exists */
3093 if (rename (old, new) == 0)
3095 if (errno != EEXIST)
3098 #endif /* WINDOWSNT */
3099 return rename (old, new);
3101 #endif /* ENCAPSULATE_RENAME */
3104 #ifdef ENCAPSULATE_SYMLINK
3106 sys_symlink (CONST char *name1, CONST char *name2)
3108 PATHNAME_CONVERT_OUT (name1);
3109 PATHNAME_CONVERT_OUT (name2);
3110 return symlink (name1, name2);
3112 #endif /* ENCAPSULATE_SYMLINK */
3115 #ifdef ENCAPSULATE_UNLINK
3117 sys_unlink (CONST char *path)
3119 PATHNAME_CONVERT_OUT (path);
3120 return unlink (path);
3122 #endif /* ENCAPSULATE_UNLINK */
3125 #ifdef ENCAPSULATE_EXECVP
3127 sys_execvp (CONST char *path, char * CONST * argv)
3132 PATHNAME_CONVERT_OUT (path);
3133 for (argc = 0; argv[argc]; argc++)
3135 new_argv = alloca_array (char *, argc + 1);
3136 for (i = 0; i < argc; i++)
3138 new_argv[i] = argv[i];
3139 PATHNAME_CONVERT_OUT (new_argv[i]);
3141 new_argv[argc] = NULL;
3142 return execvp (path, new_argv);
3144 #endif /* ENCAPSULATE_EXECVP */
3147 /************************************************************************/
3148 /* Emulations of missing system calls */
3149 /************************************************************************/
3151 /***** (these are primarily required for USG, it seems) *****/
3155 getcwd (char *pathname, int size)
3157 return getwd (pathname);
3159 #endif /* emulate getcwd */
3164 * Warning, this function may not duplicate BSD 4.2 action properly
3165 * under error conditions.
3170 getwd (char *pathname)
3172 char *npath, *spath;
3173 #if !__STDC__ && !defined(STDC_HEADERS)
3174 extern char *getcwd ();
3177 spath = npath = getcwd ((char *) 0, MAXPATHLEN);
3180 /* On Altos 3068, getcwd can return @hostname/dir, so discard
3181 up to first slash. Should be harmless on other systems. */
3182 while (*npath && *npath != '/')
3184 strcpy (pathname, npath);
3185 xfree (spath); /* getcwd uses malloc */
3188 #endif /* HAVE_GETWD */
3189 #endif /* 0 - mrb */
3192 * Emulate rename using unlink/link. Note that this is
3193 * only partially correct. Also, doesn't enforce restriction
3194 * that files be of same type (regular->regular, dir->dir, etc).
3199 rename (CONST char *from, CONST char *to)
3201 if (access (from, 0) == 0)
3204 if (link (from, to) == 0)
3205 if (unlink (from) == 0)
3210 #endif /* HAVE_RENAME */
3215 /* HPUX curses library references perror, but as far as we know
3216 it won't be called. Anyway this definition will do for now. */
3222 #endif /* not HAVE_PERROR */
3228 * Emulate BSD dup2. First close newd if it already exists.
3229 * Then, attempt to dup oldd. If not successful, call dup2 recursively
3230 * until we are, then close the unsuccessful ones.
3234 dup2 (int oldd, int newd)
3241 fd = fcntl (oldd, F_DUPFD, newd);
3243 error ("can't dup2 (%i,%i) : %s", oldd, newd, strerror (errno));
3250 ret = dup2 (old, new);
3253 #endif /* F_DUPFD */
3256 #endif /* not HAVE_DUP2 */
3259 * Gettimeofday. Simulate as much as possible. Only accurate
3260 * to nearest second. Emacs doesn't use tzp so ignore it for now.
3263 #if !defined (HAVE_GETTIMEOFDAY)
3266 gettimeofday (struct timeval *tp, struct timezone *tzp)
3268 extern long time ();
3270 tp->tv_sec = time ((long *)0);
3273 tzp->tz_minuteswest = -1;
3277 #endif /* !HAVE_GETTIMEOFDAY */
3279 /* No need to encapsulate utime and utimes explicitly because all
3280 access to those functions goes through the following. */
3283 set_file_times (char *filename, EMACS_TIME atime, EMACS_TIME mtime)
3286 struct timeval tv[2];
3289 return utimes (filename, tv);
3290 #else /* not HAVE_UTIMES */
3292 utb.actime = EMACS_SECS (atime);
3293 utb.modtime = EMACS_SECS (mtime);
3294 return utime (filename, &utb);
3295 #endif /* not HAVE_UTIMES */
3300 static long ticks_per_second;
3301 static long orig_user_ticks, orig_system_ticks;
3302 EMACS_TIME orig_real_time;
3304 static int process_times_available;
3306 /* Return the relative user and system tick count. We try to
3307 maintain calculations in terms of integers as long as possible
3308 for increased accuracy. */
3311 get_process_times_1 (long *user_ticks, long *system_ticks)
3313 #if defined (_SC_CLK_TCK) || defined (CLK_TCK) && !defined(WINDOWSNT)
3314 /* We have the POSIX times() function available. */
3317 *user_ticks = (long) tttt.tms_utime;
3318 *system_ticks = (long) tttt.tms_stime;
3320 #elif defined (CLOCKS_PER_SEC)
3321 *user_ticks = (long) clock ();
3330 init_process_times_very_early (void)
3332 #if defined (_SC_CLK_TCK)
3333 ticks_per_second = sysconf (_SC_CLK_TCK);
3334 #elif defined (CLK_TCK)
3335 ticks_per_second = CLK_TCK;
3336 #elif defined (CLOCKS_PER_SEC)
3337 ticks_per_second = CLOCKS_PER_SEC;
3340 process_times_available = get_process_times_1 (&orig_user_ticks,
3341 &orig_system_ticks);
3342 EMACS_GET_TIME (orig_real_time);
3345 /* Return the user and system times used up by this process so far. */
3347 get_process_times (double *user_time, double *system_time, double *real_time)
3349 EMACS_TIME curr_real_time;
3350 EMACS_TIME elapsed_time;
3351 long curr_user_ticks, curr_system_ticks;
3353 EMACS_GET_TIME (curr_real_time);
3354 EMACS_SUB_TIME (elapsed_time, curr_real_time, orig_real_time);
3355 *real_time = (EMACS_SECS (elapsed_time)
3356 + ((double) EMACS_USECS (elapsed_time)) / 1000000);
3357 if (get_process_times_1 (&curr_user_ticks, &curr_system_ticks))
3359 *user_time = (((double) (curr_user_ticks - orig_user_ticks))
3360 / ticks_per_second);
3361 *system_time = (((double) (curr_system_ticks - orig_system_ticks))
3362 / ticks_per_second);
3367 *user_time = *real_time;
3378 /* Figure out how many bits the system's random number generator uses.
3379 `random' and `lrand48' are assumed to return 31 usable bits.
3380 BSD `rand' returns a 31 bit value but the low order bits are unusable;
3381 so we'll shift it and treat it like the 15-bit USG `rand'. */
3385 # define RAND_BITS 31
3386 # else /* !HAVE_RANDOM */
3387 # ifdef HAVE_LRAND48
3388 # define RAND_BITS 31
3389 # define random lrand48
3390 # else /* !HAVE_LRAND48 */
3391 # define RAND_BITS 15
3392 # if RAND_MAX == 32767
3393 # define random rand
3394 # else /* RAND_MAX != 32767 */
3395 # if RAND_MAX == 2147483647
3396 # define random() (rand () >> 16)
3397 # else /* RAND_MAX != 2147483647 */
3399 # define random rand
3401 # define random() (rand () >> 16)
3403 # endif /* RAND_MAX != 2147483647 */
3404 # endif /* RAND_MAX != 32767 */
3405 # endif /* !HAVE_LRAND48 */
3406 # endif /* !HAVE_RANDOM */
3407 #endif /* !RAND_BITS */
3409 void seed_random (long arg);
3411 seed_random (long arg)
3414 srandom ((unsigned int)arg);
3416 # ifdef HAVE_LRAND48
3419 srand ((unsigned int)arg);
3425 * Build a full Emacs-sized word out of whatever we've got.
3426 * This suffices even for a 64-bit architecture with a 15-bit rand.
3428 long get_random (void);
3432 long val = random ();
3433 #if VALBITS > RAND_BITS
3434 val = (val << RAND_BITS) ^ random ();
3435 #if VALBITS > 2*RAND_BITS
3436 val = (val << RAND_BITS) ^ random ();
3437 #if VALBITS > 3*RAND_BITS
3438 val = (val << RAND_BITS) ^ random ();
3439 #if VALBITS > 4*RAND_BITS
3440 val = (val << RAND_BITS) ^ random ();
3441 #endif /* need at least 5 */
3442 #endif /* need at least 4 */
3443 #endif /* need at least 3 */
3444 #endif /* need at least 2 */
3445 return val & ((1L << VALBITS) - 1);
3449 /************************************************************************/
3450 /* Strings corresponding to defined signals */
3451 /************************************************************************/
3453 #if !defined (SYS_SIGLIST_DECLARED) && !defined (HAVE_SYS_SIGLIST)
3455 #if defined(WINDOWSNT) || defined(__CYGWIN32__)
3456 CONST char *sys_siglist[] =
3462 "illegal instruction",
3466 "floating point exception",
3469 "segmentation violation",
3470 "bad argument to system call",
3471 "write on a pipe with no one to read it",
3473 "software termination signal from kill",
3475 "sendable stop signal not from tty",
3476 "stop signal from tty",
3477 "continue a stopped process",
3478 "child status has changed",
3479 "background read attempted from control tty",
3480 "background write attempted from control tty",
3481 "input record available at control tty",
3482 "exceeded CPU time limit",
3483 "exceeded file size limit"
3489 CONST char *sys_siglist[NSIG + 1] =
3491 /* AIX has changed the signals a bit */
3492 DEFER_GETTEXT ("bogus signal"), /* 0 */
3493 DEFER_GETTEXT ("hangup"), /* 1 SIGHUP */
3494 DEFER_GETTEXT ("interrupt"), /* 2 SIGINT */
3495 DEFER_GETTEXT ("quit"), /* 3 SIGQUIT */
3496 DEFER_GETTEXT ("illegal instruction"), /* 4 SIGILL */
3497 DEFER_GETTEXT ("trace trap"), /* 5 SIGTRAP */
3498 DEFER_GETTEXT ("IOT instruction"), /* 6 SIGIOT */
3499 DEFER_GETTEXT ("crash likely"), /* 7 SIGDANGER */
3500 DEFER_GETTEXT ("floating point exception"), /* 8 SIGFPE */
3501 DEFER_GETTEXT ("kill"), /* 9 SIGKILL */
3502 DEFER_GETTEXT ("bus error"), /* 10 SIGBUS */
3503 DEFER_GETTEXT ("segmentation violation"), /* 11 SIGSEGV */
3504 DEFER_GETTEXT ("bad argument to system call"), /* 12 SIGSYS */
3505 DEFER_GETTEXT ("write on a pipe with no one to read it"), /* 13 SIGPIPE */
3506 DEFER_GETTEXT ("alarm clock"), /* 14 SIGALRM */
3507 DEFER_GETTEXT ("software termination signum"), /* 15 SIGTERM */
3508 DEFER_GETTEXT ("user defined signal 1"), /* 16 SIGUSR1 */
3509 DEFER_GETTEXT ("user defined signal 2"), /* 17 SIGUSR2 */
3510 DEFER_GETTEXT ("death of a child"), /* 18 SIGCLD */
3511 DEFER_GETTEXT ("power-fail restart"), /* 19 SIGPWR */
3512 DEFER_GETTEXT ("bogus signal"), /* 20 */
3513 DEFER_GETTEXT ("bogus signal"), /* 21 */
3514 DEFER_GETTEXT ("bogus signal"), /* 22 */
3515 DEFER_GETTEXT ("bogus signal"), /* 23 */
3516 DEFER_GETTEXT ("bogus signal"), /* 24 */
3517 DEFER_GETTEXT ("LAN I/O interrupt"), /* 25 SIGAIO */
3518 DEFER_GETTEXT ("PTY I/O interrupt"), /* 26 SIGPTY */
3519 DEFER_GETTEXT ("I/O intervention required"), /* 27 SIGIOINT */
3521 DEFER_GETTEXT ("HFT grant"), /* 28 SIGGRANT */
3522 DEFER_GETTEXT ("HFT retract"), /* 29 SIGRETRACT */
3523 DEFER_GETTEXT ("HFT sound done"), /* 30 SIGSOUND */
3524 DEFER_GETTEXT ("HFT input ready"), /* 31 SIGMSG */
3528 #else /* USG, not AIX */
3529 CONST char *sys_siglist[NSIG + 1] =
3531 DEFER_GETTEXT ("bogus signal"), /* 0 */
3532 DEFER_GETTEXT ("hangup"), /* 1 SIGHUP */
3533 DEFER_GETTEXT ("interrupt"), /* 2 SIGINT */
3534 DEFER_GETTEXT ("quit"), /* 3 SIGQUIT */
3535 DEFER_GETTEXT ("illegal instruction"), /* 4 SIGILL */
3536 DEFER_GETTEXT ("trace trap"), /* 5 SIGTRAP */
3537 DEFER_GETTEXT ("IOT instruction"), /* 6 SIGIOT */
3538 DEFER_GETTEXT ("EMT instruction"), /* 7 SIGEMT */
3539 DEFER_GETTEXT ("floating point exception"), /* 8 SIGFPE */
3540 DEFER_GETTEXT ("kill"), /* 9 SIGKILL */
3541 DEFER_GETTEXT ("bus error"), /* 10 SIGBUS */
3542 DEFER_GETTEXT ("segmentation violation"), /* 11 SIGSEGV */
3543 DEFER_GETTEXT ("bad argument to system call"), /* 12 SIGSYS */
3544 DEFER_GETTEXT ("write on a pipe with no one to read it"), /* 13 SIGPIPE */
3545 DEFER_GETTEXT ("alarm clock"), /* 14 SIGALRM */
3546 DEFER_GETTEXT ("software termination signum"), /* 15 SIGTERM */
3547 DEFER_GETTEXT ("user defined signal 1"), /* 16 SIGUSR1 */
3548 DEFER_GETTEXT ("user defined signal 2"), /* 17 SIGUSR2 */
3549 DEFER_GETTEXT ("death of a child"), /* 18 SIGCLD */
3550 DEFER_GETTEXT ("power-fail restart"), /* 19 SIGPWR */
3552 DEFER_GETTEXT ("window size changed"), /* 20 SIGWINCH */
3553 DEFER_GETTEXT ("urgent socket condition"), /* 21 SIGURG */
3554 DEFER_GETTEXT ("pollable event occurred"), /* 22 SIGPOLL */
3555 DEFER_GETTEXT ("stop (cannot be caught or ignored)"), /* 23 SIGSTOP */
3556 DEFER_GETTEXT ("user stop requested from tty"), /* 24 SIGTSTP */
3557 DEFER_GETTEXT ("stopped process has been continued"), /* 25 SIGCONT */
3558 DEFER_GETTEXT ("background tty read attempted"), /* 26 SIGTTIN */
3559 DEFER_GETTEXT ("background tty write attempted"), /* 27 SIGTTOU */
3560 DEFER_GETTEXT ("virtual timer expired"), /* 28 SIGVTALRM */
3561 DEFER_GETTEXT ("profiling timer expired"), /* 29 SIGPROF */
3562 DEFER_GETTEXT ("exceeded cpu limit"), /* 30 SIGXCPU */
3563 DEFER_GETTEXT ("exceeded file size limit"), /* 31 SIGXFSZ */
3564 DEFER_GETTEXT ("process's lwps are blocked"), /* 32 SIGWAITING */
3565 DEFER_GETTEXT ("special signal used by thread library"), /* 33 SIGLWP */
3567 DEFER_GETTEXT ("special signal used by CPR"), /* 34 SIGFREEZE */
3570 DEFER_GETTEXT ("special signal used by CPR"), /* 35 SIGTHAW */
3575 #endif /* not AIX */
3578 CONST char *sys_siglist[NSIG + 1] =
3580 DEFER_GETTEXT ("null signal"), /* 0 SIGNULL */
3581 DEFER_GETTEXT ("hangup"), /* 1 SIGHUP */
3582 DEFER_GETTEXT ("interrupt"), /* 2 SIGINT */
3583 DEFER_GETTEXT ("quit"), /* 3 SIGQUIT */
3584 DEFER_GETTEXT ("illegal instruction"), /* 4 SIGILL */
3585 DEFER_GETTEXT ("trace trap"), /* 5 SIGTRAP */
3586 DEFER_GETTEXT ("abort termination"), /* 6 SIGABRT */
3587 DEFER_GETTEXT ("SIGEMT"), /* 7 SIGEMT */
3588 DEFER_GETTEXT ("floating point exception"), /* 8 SIGFPE */
3589 DEFER_GETTEXT ("kill"), /* 9 SIGKILL */
3590 DEFER_GETTEXT ("bus error"), /* 10 SIGBUS */
3591 DEFER_GETTEXT ("segmentation violation"), /* 11 SIGSEGV */
3592 DEFER_GETTEXT ("bad argument to system call"), /* 12 SIGSYS */
3593 DEFER_GETTEXT ("write on a pipe with no reader"), /* 13 SIGPIPE */
3594 DEFER_GETTEXT ("alarm clock"), /* 14 SIGALRM */
3595 DEFER_GETTEXT ("software termination signal"), /* 15 SIGTERM */
3596 DEFER_GETTEXT ("user defined signal 1"), /* 16 SIGUSR1 */
3597 DEFER_GETTEXT ("user defined signal 2"), /* 17 SIGUSR2 */
3598 DEFER_GETTEXT ("child stopped or terminated"), /* 18 SIGCLD */
3599 DEFER_GETTEXT ("power-fail restart"), /* 19 SIGPWR */
3600 DEFER_GETTEXT ("window size changed"), /* 20 SIGWINCH */
3601 DEFER_GETTEXT ("undefined"), /* 21 */
3602 DEFER_GETTEXT ("pollable event occurred"), /* 22 SIGPOLL */
3603 DEFER_GETTEXT ("sendable stop signal not from tty"), /* 23 SIGSTOP */
3604 DEFER_GETTEXT ("stop signal from tty"), /* 24 SIGSTP */
3605 DEFER_GETTEXT ("continue a stopped process"), /* 25 SIGCONT */
3606 DEFER_GETTEXT ("attempted background tty read"), /* 26 SIGTTIN */
3607 DEFER_GETTEXT ("attempted background tty write"), /* 27 SIGTTOU */
3608 DEFER_GETTEXT ("undefined"), /* 28 */
3609 DEFER_GETTEXT ("undefined"), /* 29 */
3610 DEFER_GETTEXT ("undefined"), /* 30 */
3611 DEFER_GETTEXT ("undefined"), /* 31 */
3612 DEFER_GETTEXT ("undefined"), /* 32 */
3613 DEFER_GETTEXT ("socket (TCP/IP) urgent data arrival"), /* 33 SIGURG */
3614 DEFER_GETTEXT ("I/O is possible"), /* 34 SIGIO */
3615 DEFER_GETTEXT ("exceeded cpu time limit"), /* 35 SIGXCPU */
3616 DEFER_GETTEXT ("exceeded file size limit"), /* 36 SIGXFSZ */
3617 DEFER_GETTEXT ("virtual time alarm"), /* 37 SIGVTALRM */
3618 DEFER_GETTEXT ("profiling time alarm"), /* 38 SIGPROF */
3619 DEFER_GETTEXT ("undefined"), /* 39 */
3620 DEFER_GETTEXT ("file record locks revoked"), /* 40 SIGLOST */
3621 DEFER_GETTEXT ("undefined"), /* 41 */
3622 DEFER_GETTEXT ("undefined"), /* 42 */
3623 DEFER_GETTEXT ("undefined"), /* 43 */
3624 DEFER_GETTEXT ("undefined"), /* 44 */
3625 DEFER_GETTEXT ("undefined"), /* 45 */
3626 DEFER_GETTEXT ("undefined"), /* 46 */
3627 DEFER_GETTEXT ("undefined"), /* 47 */
3628 DEFER_GETTEXT ("undefined"), /* 48 */
3629 DEFER_GETTEXT ("undefined"), /* 49 */
3630 DEFER_GETTEXT ("undefined"), /* 50 */
3631 DEFER_GETTEXT ("undefined"), /* 51 */
3632 DEFER_GETTEXT ("undefined"), /* 52 */
3633 DEFER_GETTEXT ("undefined"), /* 53 */
3634 DEFER_GETTEXT ("undefined"), /* 54 */
3635 DEFER_GETTEXT ("undefined"), /* 55 */
3636 DEFER_GETTEXT ("undefined"), /* 56 */
3637 DEFER_GETTEXT ("undefined"), /* 57 */
3638 DEFER_GETTEXT ("undefined"), /* 58 */
3639 DEFER_GETTEXT ("undefined"), /* 59 */
3640 DEFER_GETTEXT ("undefined"), /* 60 */
3641 DEFER_GETTEXT ("undefined"), /* 61 */
3642 DEFER_GETTEXT ("undefined"), /* 62 */
3643 DEFER_GETTEXT ("undefined"), /* 63 */
3644 DEFER_GETTEXT ("notification message in mess. queue"), /* 64 SIGDGNOTIFY */
3649 #endif /* ! SYS_SIGLIST_DECLARED && ! HAVE_SYS_SIGLIST */
3652 /************************************************************************/
3653 /* Directory routines for systems that don't have them */
3654 /************************************************************************/
3656 #ifdef SYSV_SYSTEM_DIR
3660 #if defined(BROKEN_CLOSEDIR) || !defined(HAVE_CLOSEDIR)
3662 closedir (DIR *dirp) /* stream from opendir */
3666 rtnval = sys_close (dirp->dd_fd);
3668 /* Some systems (like Solaris) allocate the buffer and the DIR all
3669 in one block. Why in the world are we freeing this ourselves
3671 #if ! (defined (sun) && defined (USG5_4))
3672 xfree ((char *) dirp->dd_buf); /* directory block defined in <dirent.h> */
3674 xfree ((char *) dirp);
3677 #endif /* BROKEN_CLOSEDIR or not HAVE_CLOSEDIR */
3678 #endif /* SYSV_SYSTEM_DIR */
3680 #ifdef NONSYSTEM_DIR_LIBRARY
3683 opendir (CONST char *filename) /* name of directory */
3685 DIR *dirp; /* -> malloc'ed storage */
3686 int fd; /* file descriptor for read */
3687 struct stat sbuf; /* result of fstat */
3689 fd = sys_open (filename, O_RDONLY);
3693 if (fstat (fd, &sbuf) < 0
3694 || (sbuf.st_mode & S_IFMT) != S_IFDIR
3695 || (dirp = (DIR *) malloc (sizeof (DIR))) == 0)
3698 return 0; /* bad luck today */
3702 dirp->dd_loc = dirp->dd_size = 0; /* refill needed */
3708 closedir (DIR *dirp) /* stream from opendir */
3710 sys_close (dirp->dd_fd);
3718 ino_t od_ino; /* inode */
3719 char od_name[DIRSIZ]; /* filename */
3722 static struct direct dir_static; /* simulated directory contents */
3726 readdir (DIR *dirp) /* stream from opendir */
3728 struct olddir *dp; /* -> directory data */
3732 if (dirp->dd_loc >= dirp->dd_size)
3733 dirp->dd_loc = dirp->dd_size = 0;
3735 if (dirp->dd_size == 0 /* refill buffer */
3736 && (dirp->dd_size = sys_read (dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ)) <= 0)
3739 dp = (struct olddir *) &dirp->dd_buf[dirp->dd_loc];
3740 dirp->dd_loc += sizeof (struct olddir);
3742 if (dp->od_ino != 0) /* not deleted entry */
3744 dir_static.d_ino = dp->od_ino;
3745 strncpy (dir_static.d_name, dp->od_name, DIRSIZ);
3746 dir_static.d_name[DIRSIZ] = '\0';
3747 dir_static.d_namlen = strlen (dir_static.d_name);
3748 dir_static.d_reclen = sizeof (struct direct)
3750 + dir_static.d_namlen - dir_static.d_namlen % 4;
3751 return &dir_static; /* -> simulated structure */
3757 #endif /* NONSYSTEM_DIR_LIBRARY */
3760 /* mkdir and rmdir functions, for systems which don't have them. */
3764 * Written by Robert Rother, Mariah Corporation, August 1985.
3766 * If you want it, it's yours. All I ask in return is that if you
3767 * figure out how to do this in a Bourne Shell script you send me
3769 * sdcsvax!rmr or rmr@uscd
3771 * Severely hacked over by John Gilmore to make a 4.2BSD compatible
3772 * subroutine. 11Mar86; hoptoad!gnu
3774 * Modified by rmtodd@uokmax 6-28-87 -- when making an already existing dir,
3775 * subroutine didn't return EEXIST. It does now.
3781 #ifdef MKDIR_PROTOTYPE
3785 mkdir (CONST char *dpath, int dmode)
3788 int cpid, status, fd;
3789 struct stat statbuf;
3791 if (stat (dpath, &statbuf) == 0)
3793 errno = EEXIST; /* Stat worked, so it already exists */
3797 /* If stat fails for a reason other than non-existence, return error */
3798 if (errno != ENOENT)
3801 synch_process_alive = 1;
3802 switch (cpid = fork ())
3805 case -1: /* Error in fork() */
3806 return -1; /* Errno is set already */
3808 case 0: /* Child process */
3811 * Cheap hack to set mode of new directory. Since this
3812 * child process is going away anyway, we zap its umask.
3813 * ####, this won't suffice to set SUID, SGID, etc. on this
3814 * directory. Does anybody care?
3816 status = umask (0); /* Get current umask */
3817 status = umask (status | (0777 & ~dmode)); /* Set for mkdir */
3818 fd = sys_open ("/dev/null", O_RDWR);
3821 if (fd != STDIN_FILENO) dup2 (fd, STDIN_FILENO);
3822 if (fd != STDOUT_FILENO) dup2 (fd, STDOUT_FILENO);
3823 if (fd != STDERR_FILENO) dup2 (fd, STDERR_FILENO);
3825 execl ("/bin/mkdir", "mkdir", dpath, (char *) 0);
3826 _exit (-1); /* Can't exec /bin/mkdir */
3829 default: /* Parent process */
3830 wait_for_termination (cpid);
3833 if (synch_process_death != 0 || synch_process_retcode != 0)
3835 errno = EIO; /* We don't know why, but */
3836 return -1; /* /bin/mkdir failed */
3841 #endif /* not HAVE_MKDIR */
3845 rmdir (CONST char *dpath)
3847 int cpid, status, fd;
3848 struct stat statbuf;
3850 if (stat (dpath, &statbuf) != 0)
3852 /* Stat just set errno. We don't have to */
3856 synch_process_alive = 1;
3857 switch (cpid = fork ())
3860 case -1: /* Error in fork() */
3861 return (-1); /* Errno is set already */
3863 case 0: /* Child process */
3864 fd = sys_open("/dev/null", O_RDWR);
3867 if (fd != STDIN_FILENO) dup2 (fd, STDIN_FILENO);
3868 if (fd != STDOUT_FILENO) dup2 (fd, STDOUT_FILENO);
3869 if (fd != STDERR_FILENO) dup2 (fd, STDERR_FILENO);
3871 execl ("/bin/rmdir", "rmdir", dpath, (char *) 0);
3872 _exit (-1); /* Can't exec /bin/mkdir */
3874 default: /* Parent process */
3875 wait_for_termination (cpid);
3878 if (synch_process_death != 0 ||
3879 synch_process_retcode != 0)
3881 errno = EIO; /* We don't know why, but */
3882 return -1; /* /bin/rmdir failed */
3887 #endif /* !HAVE_RMDIR */
3890 /************************************************************************/
3891 /* Misc. SunOS crap */
3892 /************************************************************************/
3896 /* These are included on Sunos 4.1 when we do not use shared libraries.
3897 X11 libraries may refer to these functions but (we hope) do not
3898 actually call them. */
3918 #endif /* USE_DL_STUBS */
3922 #ifndef HAVE_STRCASECMP
3926 static unsigned char charmap[] = {
3927 '\000', '\001', '\002', '\003', '\004', '\005', '\006', '\007',
3928 '\010', '\011', '\012', '\013', '\014', '\015', '\016', '\017',
3929 '\020', '\021', '\022', '\023', '\024', '\025', '\026', '\027',
3930 '\030', '\031', '\032', '\033', '\034', '\035', '\036', '\037',
3931 '\040', '\041', '\042', '\043', '\044', '\045', '\046', '\047',
3932 '\050', '\051', '\052', '\053', '\054', '\055', '\056', '\057',
3933 '\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067',
3934 '\070', '\071', '\072', '\073', '\074', '\075', '\076', '\077',
3935 '\100', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
3936 '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
3937 '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
3938 '\170', '\171', '\172', '\133', '\134', '\135', '\136', '\137',
3939 '\140', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
3940 '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
3941 '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
3942 '\170', '\171', '\172', '\173', '\174', '\175', '\176', '\177',
3943 '\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207',
3944 '\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217',
3945 '\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227',
3946 '\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237',
3947 '\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247',
3948 '\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257',
3949 '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267',
3950 '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277',
3951 '\300', '\301', '\302', '\303', '\304', '\305', '\306', '\307',
3952 '\310', '\311', '\312', '\313', '\314', '\315', '\316', '\317',
3953 '\320', '\321', '\322', '\323', '\324', '\325', '\326', '\327',
3954 '\330', '\331', '\332', '\333', '\334', '\335', '\336', '\337',
3955 '\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347',
3956 '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357',
3957 '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367',
3958 '\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377',
3962 strcasecmp (char *s1, char *s2)
3964 unsigned char *cm = charmap;
3965 unsigned char *us1 = (unsigned char *) s1;
3966 unsigned char *us2 = (unsigned char *)s2;
3968 while (cm[*us1] == cm[*us2++])
3972 return (cm[*us1] - cm[*--us2]);
3974 #endif /* !HAVE_STRCASECMP */