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 */
55 /* ------------------------------- */
57 /* ------------------------------- */
60 #include "console-tty.h"
62 #include "syssignal.h"
66 #include "console-stream.h"
71 #include "redisplay.h"
77 #ifdef HAVE_LIBGEN_H /* Must come before sysfile.h */
84 #if defined(WINDOWSNT) || defined(__CYGWIN32__)
85 #include "syssignal.h"
88 #include <sys/times.h>
92 #include <sys/utime.h>
97 /* ------------------------------- */
99 /* ------------------------------- */
102 #include <sys/utsname.h>
103 #if defined (TIOCGWINSZ) || defined (ISC4_0)
105 #include <sys/sioctl.h>
108 #include <sys/stream.h>
109 #include <sys/ptem.h>
111 #endif /* TIOCGWINSZ or ISC4_0 */
114 #ifdef HAVE_SYS_STROPTS_H
115 #include <sys/stropts.h>
116 #endif /* HAVE_SYS_STROPTS_H */
118 /* LPASS8 is new in 4.3, and makes cbreak mode provide all 8 bits. */
129 static int baud_convert[] =
134 0, 50, 75, 110, 135, 150, 200, 300, 600, 1200,
135 1800, 2400, 4800, 9600, 19200, 38400
142 static void hft_init (struct console *c);
143 static void hft_reset (struct console *c);
144 #include <sys/termio.h>
147 /* ------------------------------- */
149 /* ------------------------------- */
152 #ifndef HAVE_STRUCT_UTIMBUF
153 /* We want to use utime rather than utimes, but we couldn't find the
154 structure declaration. We'll use the traditional one. */
164 /************************************************************************/
165 /* subprocess control */
166 /************************************************************************/
172 /* Arrange for character C to be read as the next input from
175 stuff_char (struct console *con, int c)
179 assert (CONSOLE_TTY_P (con));
180 input_fd = CONSOLE_TTY_DATA (con)->infd;
181 /* Should perhaps error if in batch mode */
183 ioctl (input_fd, TIOCSTI, &c);
184 #else /* no TIOCSTI */
185 error ("Cannot stuff terminal input characters in this version of Unix.");
186 #endif /* no TIOCSTI */
191 #endif /* HAVE_TTY */
194 set_exclusive_use (int fd)
197 ioctl (fd, FIOCLEX, 0);
199 /* Ok to do nothing if this feature does not exist */
203 set_descriptor_non_blocking (int fd)
205 /* Stride people say it's a mystery why this is needed
206 as well as the O_NDELAY, but that it fails without this. */
207 /* For AIX: Apparently need this for non-blocking reads on sockets.
208 It seems that O_NONBLOCK applies only to FIFOs? From
209 lowry@watson.ibm.com (Andy Lowry). */
210 /* #### Should this be conditionalized on FIONBIO? */
211 #if defined (STRIDE) || (defined (pfa) && defined (HAVE_PTYS)) || defined (AIX)
214 ioctl (fd, FIONBIO, &one);
219 fcntl (fd, F_SETFL, O_NONBLOCK);
223 #if defined (NO_SUBPROCESSES)
227 wait_without_blocking (void)
229 wait3 (0, WNOHANG | WUNTRACED, 0);
230 synch_process_alive = 0;
234 #endif /* NO_SUBPROCESSES */
238 wait_for_termination (int pid)
240 /* #### With the new improved SIGCHLD handling stuff, there is much
241 less danger of race conditions and some of the comments below
242 don't apply. This should be updated. */
244 #if defined (NO_SUBPROCESSES)
247 /* No need to be tricky like below; we can just call wait(). */
248 /* #### should figure out how to write a wait_allowing_quit().
249 Since hardly any systems don't have subprocess support,
250 however, there doesn't seem to be much point. */
254 #elif defined (HAVE_WAITPID)
255 /* Note that, whenever any subprocess terminates (asynch. or synch.),
256 the SIGCHLD handler will be called and it will call wait(). Thus
257 we cannot just call wait() ourselves, and we can't block SIGCHLD
258 and then call wait(), because then if an asynch. process dies
259 while we're waiting for our synch. process, Emacs will never
260 notice that the asynch. process died.
262 So, the general approach we take is to repeatedly block until a
263 signal arrives, and then check if our process died using kill
264 (pid, 0). (We could also check the value of `synch_process_alive',
265 since the SIGCHLD handler will reset that and we know that we're
266 only being called on synchronous processes, but this approach is
267 safer. I don't trust the proper delivery of SIGCHLD.
269 Note also that we cannot use any form of waitpid(). A loop with
270 WNOHANG will chew up CPU time; better to use sleep(). A loop
271 without WNOWAIT will screw up the SIGCHLD handler (actually this
272 is not true, if you duplicate the exit-status-reaping code; see
273 below). A loop with WNOWAIT will result in a race condition if
274 the process terminates between the process-status check and the
275 call to waitpid(). */
277 /* Formerly, immediate_quit was set around this function call, but
278 that could lead to problems if the QUIT happened when SIGCHLD was
279 blocked -- it would remain blocked. Yet another reason why
280 immediate_quit is a bad idea. In any case, there is no reason to
281 resort to this because either the SIGIO or the SIGALRM will stop
282 the block in EMACS_WAIT_FOR_SIGNAL(). */
284 /* Apparently there are bugs on some systems with the second method
285 used below (the EMACS_BLOCK_SIGNAL method), whereby zombie
286 processes get left around. It appears in those cases that the
287 SIGCHLD handler is never getting invoked. It's not clear whether
288 this is an Emacs bug or a kernel bug or both: on HPUX this
289 problem is observed only with XEmacs, but under Solaris 2.4 all
290 sorts of different programs have problems with zombies. The
291 method we use here does not require a working SIGCHLD (but will
292 not break if it is working), and should be safe. */
294 We use waitpid(), contrary to the remarks above. There is no
295 race condition, because the three situations when sigchld_handler
296 is invoked should be handled OK:
298 - handler invoked before waitpid(): In this case, subprocess
299 status will be set by sigchld_handler. waitpid() here will
300 return -1 with errno set to ECHILD, which is a valid exit
303 - handler invoked during waitpid(): as above, except that errno
304 here will be set to EINTR. This will cause waitpid() to be
305 called again, and this time it will exit with ECHILD.
307 - handler invoked after waitpid(): The following code will reap
308 the subprocess. In the handler, wait() will return -1 because
309 there is no child to reap, and the handler will exit without
310 modifying child subprocess status. */
313 /* Because the SIGCHLD handler can potentially reap the synchronous
314 subprocess, we should take care of that. */
316 /* Will stay in the do loop as long as:
318 2. Ctrl-G is not pressed */
322 ret = waitpid (pid, &status, 0);
323 /* waitpid returns 0 if the process is still alive. */
325 while (ret == 0 || (ret == -1 && errno == EINTR));
327 if (ret == pid) /* Success */
328 /* Set synch process globals. This is can also happen
329 in sigchld_handler, and that code is duplicated. */
331 synch_process_alive = 0;
332 if (WIFEXITED (status))
333 synch_process_retcode = WEXITSTATUS (status);
334 else if (WIFSIGNALED (status))
335 synch_process_death = signal_name (WTERMSIG (status));
337 /* On exiting the loop, ret will be -1, with errno set to ECHILD if
338 the child has already been reaped, e.g. in the signal handler. */
340 /* Otherwise, we've had some error condition here.
341 Per POSIX, the only other possibilities are:
342 - EFAULT (bus error accessing arg 2) or
343 - EINVAL (incorrect arguments),
344 which are both program bugs.
346 Since implementations may add their own error indicators on top,
347 we ignore it by default. */
348 #elif defined (EMACS_BLOCK_SIGNAL) && !defined (BROKEN_WAIT_FOR_SIGNAL) && defined (SIGCHLD)
351 static int wait_debugging = 0; /* Set nonzero to make following
352 function work under dbx (at least for bsd). */
357 EMACS_BLOCK_SIGNAL (SIGCHLD);
358 /* Block SIGCHLD from happening during this check,
359 to avoid race conditions. */
360 if (kill (pid, 0) < 0)
362 EMACS_UNBLOCK_SIGNAL (SIGCHLD);
366 /* WARNING: Whatever this macro does *must* not allow SIGCHLD
367 to happen between the time that it's reenabled and when we
368 begin to block. Otherwise we may end up blocking for a
369 signal that has already arrived and isn't coming again.
370 Can you say "race condition"?
372 I assume that the system calls sigpause() or sigsuspend()
373 to provide this atomicness. If you're getting hangs in
374 sigpause()/sigsuspend(), then your OS doesn't implement
375 this properly (this applies under hpux9, for example).
376 Try defining BROKEN_WAIT_FOR_SIGNAL. */
377 EMACS_WAIT_FOR_SIGNAL (SIGCHLD);
379 #else /* not HAVE_WAITPID and (not EMACS_BLOCK_SIGNAL or BROKEN_WAIT_FOR_SIGNAL) */
380 /* This approach is kind of cheesy but is guaranteed(?!) to work
385 if (kill (pid, 0) < 0)
389 #endif /* OS features */
393 #if !defined (NO_SUBPROCESSES)
396 * flush any pending output
397 * (may flush input as well; it does not matter the way we use it)
401 flush_pending_output (int channel)
404 /* If we try this, we get hit with SIGTTIN, because
405 the child's tty belongs to the child's pgrp. */
406 #elif defined (TCFLSH)
407 ioctl (channel, TCFLSH, 1);
408 #elif defined (TIOCFLUSH)
410 /* 3rd arg should be ignored
411 but some 4.2 kernels actually want the address of an int
412 and nonzero means something different. */
413 ioctl (channel, TIOCFLUSH, &zero);
418 /* Set up the terminal at the other end of a pseudo-terminal that
419 we will be controlling an inferior through.
420 It should not echo or do line-editing, since that is done
421 in Emacs. No padding needed for insertion into an Emacs buffer. */
424 child_setup_tty (int out)
427 EMACS_GET_TTY (out, &s);
429 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
430 assert (isatty(out));
431 s.main.c_oflag |= OPOST; /* Enable output postprocessing */
432 s.main.c_oflag &= ~ONLCR; /* Disable map of NL to CR-NL on output */
434 s.main.c_oflag &= ~(NLDLY|CRDLY|TABDLY|BSDLY|VTDLY|FFDLY);
435 /* No output delays */
437 s.main.c_lflag &= ~ECHO; /* Disable echo */
438 s.main.c_lflag |= ISIG; /* Enable signals */
440 s.main.c_iflag &= ~IUCLC; /* Disable downcasing on input. */
443 s.main.c_oflag &= ~OLCUC; /* Disable upcasing on output. */
445 s.main.c_oflag &= ~TAB3; /* Disable tab expansion */
446 #if defined (CSIZE) && defined (CS8)
447 s.main.c_cflag = (s.main.c_cflag & ~CSIZE) | CS8; /* Don't strip 8th bit */
450 s.main.c_iflag &= ~ISTRIP; /* Don't strip 8th bit on input */
453 /* Unnecessary as long as ICANON is set */
454 s.main.c_cc[VMIN] = 1; /* minimum number of characters to accept */
455 s.main.c_cc[VTIME] = 0; /* wait forever for at least 1 character */
458 s.main.c_lflag |= ICANON; /* Enable erase/kill and eof processing */
459 s.main.c_cc[VEOF] = 04; /* ensure that EOF is Control-D */
460 s.main.c_cc[VERASE] = _POSIX_VDISABLE; /* disable erase processing */
461 s.main.c_cc[VKILL] = _POSIX_VDISABLE; /* disable kill processing */
464 s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
469 /* AIX enhanced edit loses NULs, so disable it. */
471 s.main.c_iflag &= ~ASCEDIT;
472 #endif /* IBMR2AIX */
473 /* Also, PTY overloads NUL and BREAK.
474 don't ignore break, but don't signal either, so it looks like NUL.
475 This really serves a purpose only if running in an XTERM window
476 or via TELNET or the like, but does no harm elsewhere. */
477 s.main.c_iflag &= ~IGNBRK;
478 s.main.c_iflag &= ~BRKINT;
480 #ifdef SIGNALS_VIA_CHARACTERS
481 /* TTY `special characters' are used in process_send_signal
482 so set them here to something useful. */
483 s.main.c_cc[VQUIT] = '\\'&037; /* Control-\ */
484 s.main.c_cc[VINTR] = 'C' &037; /* Control-C */
485 s.main.c_cc[VSUSP] = 'Z' &037; /* Control-Z */
486 #else /* no TIOCGPGRP or no TIOCGLTC or no TIOCGETC */
487 /* TTY `special characters' work better as signals, so disable
489 s.main.c_cc[VQUIT] = _POSIX_VDISABLE;
490 s.main.c_cc[VINTR] = _POSIX_VDISABLE;
491 s.main.c_cc[VSUSP] = _POSIX_VDISABLE;
492 s.main.c_lflag &= ~ISIG;
493 #endif /* no TIOCGPGRP or no TIOCGLTC or no TIOCGETC */
494 s.main.c_cc[VEOL] = _POSIX_VDISABLE;
496 /* <mdiers> ### This is not portable. ###
497 POSIX does not specify CBAUD, and 4.4BSD does not have it.
498 Instead, POSIX suggests to use cfset{i,o}speed().
499 [cf. D. Lewine, POSIX Programmer's Guide, Chapter 8: Terminal
500 I/O, O'Reilly 1991] */
501 s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
503 /* <mdiers> What to do upon failure? Just ignoring rc is probably
504 not acceptable, is it? */
505 if (cfsetispeed (&s.main, B9600) == -1) /* ignore */;
506 if (cfsetospeed (&s.main, B9600) == -1) /* ignore */;
507 #endif /* defined (CBAUD) */
509 #else /* not HAVE_TERMIO */
511 s.main.sg_flags &= ~(ECHO | CRMOD | ANYP | ALLDELAY | RAW | LCASE
513 s.main.sg_flags |= LPASS8;
514 s.main.sg_erase = 0377;
515 s.main.sg_kill = 0377;
516 s.lmode = LLITOUT | s.lmode; /* Don't strip 8th bit */
518 #endif /* not HAVE_TERMIO */
519 EMACS_SET_TTY (out, &s, 0);
524 ioctl (out, FIOASYNC, &zero);
528 #endif /* WINDOWSNT */
530 #endif /* not NO_SUBPROCESSES */
533 #if !defined (SIGTSTP) && !defined (USG_JOBCTRL)
535 #if defined(__STDC__) || defined(_MSC_VER)
536 #define SIG_PARAM_TYPE int
538 #define SIG_PARAM_TYPE
541 /* Record a signal code and the handler for it. */
545 SIGTYPE (*handler) (SIG_PARAM_TYPE);
549 save_signal_handlers (struct save_signal *saved_handlers)
551 while (saved_handlers->code)
553 saved_handlers->handler
554 = (SIGTYPE (*) (SIG_PARAM_TYPE)) signal (saved_handlers->code, SIG_IGN);
560 restore_signal_handlers (struct save_signal *saved_handlers)
562 while (saved_handlers->code)
564 signal (saved_handlers->code, saved_handlers->handler);
573 return abs (getpid ());
575 #endif /* WINDOWSNT */
577 /* Fork a subshell. */
582 struct save_signal saved_handlers[5];
584 unsigned char *str = 0;
588 saved_handlers[0].code = SIGINT;
589 saved_handlers[1].code = SIGQUIT;
590 saved_handlers[2].code = SIGTERM;
592 saved_handlers[3].code = SIGIO;
593 saved_handlers[4].code = 0;
595 saved_handlers[3].code = 0;
598 /* Mentioning current_buffer->buffer would mean including buffer.h,
599 which somehow wedges the hp compiler. So instead... */
601 if (NILP (Fboundp (Qdefault_directory)))
603 dir = Fsymbol_value (Qdefault_directory);
608 dir = Funhandled_file_name_directory (dir);
609 dir = expand_and_dir_to_file (dir, Qnil);
611 str = (unsigned char *) alloca (XSTRING_LENGTH (dir) + 2);
612 len = XSTRING_LENGTH (dir);
613 memcpy (str, XSTRING_DATA (dir), len);
614 /* #### Unix specific */
615 if (str[len - 1] != '/') str[len++] = '/';
621 #else /* not WINDOWSNT */
626 error ("Can't spawn subshell");
629 #endif /* not WINDOWSNT */
634 sh = (char *) egetenv ("SHELL");
638 /* Use our buffer's default directory for the subshell. */
642 #if !defined (NO_SUBPROCESSES) && !defined (WINDOWSNT)
643 close_process_descs (); /* Close Emacs's pipes/ptys */
646 #ifdef SET_EMACS_PRIORITY
647 if (emacs_priority != 0)
648 nice (-emacs_priority); /* Give the new shell the default priority */
652 /* Waits for process completion */
653 pid = _spawnlp (_P_WAIT, sh, sh, NULL);
655 write (1, "Can't execute subshell", 22);
657 #else /* not WINDOWSNT */
659 write (1, "Can't execute subshell", 22);
661 #endif /* not WINDOWSNT */
664 save_signal_handlers (saved_handlers);
665 synch_process_alive = 1;
666 wait_for_termination (pid);
667 restore_signal_handlers (saved_handlers);
670 #endif /* !defined (SIGTSTP) && !defined (USG_JOBCTRL) */
674 /* Suspend the Emacs process; give terminal to its superior. */
678 #if defined (SIGTSTP)
680 int pgrp = EMACS_GET_PROCESS_GROUP ();
681 EMACS_KILLPG (pgrp, SIGTSTP);
684 #elif defined (USG_JOBCTRL)
685 /* If you don't know what this is don't mess with it */
686 ptrace (0, 0, 0, 0); /* set for ptrace - caught by csh */
687 kill (getpid (), SIGQUIT);
689 #else /* No SIGTSTP or USG_JOBCTRL */
691 /* On a system where suspending is not implemented,
692 instead fork a subshell and let it talk directly to the terminal
699 /* Suspend a process if possible; give terminal to its superior. */
701 sys_suspend_process (int process)
703 /* I don't doubt that it is possible to suspend processes on
704 * VMS machines or thost that use USG_JOBCTRL,
705 * but I don't know how to do it, so...
707 #if defined (SIGTSTP)
708 kill(process, SIGTSTP);
713 /* Given FD, obtain pty buffer size. When no luck, a good guess is made,
714 so that the function works even fd is not a pty. */
717 get_pty_max_bytes (int fd)
721 #if defined (HAVE_FPATHCONF) && defined (_PC_MAX_CANON)
722 pty_max_bytes = fpathconf (fd, _PC_MAX_CANON);
723 if (pty_max_bytes < 0)
727 /* Deduct one, to leave space for the eof. */
730 return pty_max_bytes;
733 /* Figure out the eof character for the FD. */
736 get_eof_char (int fd)
738 CONST Bufbyte ctrl_d = (Bufbyte) '\004';
747 /* What is the following line designed to do??? -mrb */
748 if (strlen ((CONST char *) t.c_cc) < (unsigned int) (VEOF + 1))
751 return (Bufbyte) t.c_cc[VEOF];
753 return t.c_cc[VEOF] == _POSIX_VDISABLE ? ctrl_d : (Bufbyte) t.c_cc[VEOF];
755 #else /* ! HAVE_TERMIOS */
756 /* On Berkeley descendants, the following IOCTL's retrieve the
757 current control characters. */
758 #if defined (TIOCGETC)
761 ioctl (fd, TIOCGETC, &c);
762 return (Bufbyte) c.t_eofc;
764 #else /* ! defined (TIOCGLTC) && defined (TIOCGETC) */
765 /* On SYSV descendants, the TCGETA ioctl retrieves the current control
770 ioctl (fd, TCGETA, &t);
771 if (strlen ((CONST char *) t.c_cc) < (unsigned int) (VINTR + 1))
774 return (Bufbyte) t.c_cc[VINTR];
776 #else /* ! defined (TCGETA) */
777 /* Rather than complain, we'll just guess ^D, which is what
778 * earlier emacsen always used. */
780 #endif /* ! defined (TCGETA) */
781 #endif /* ! defined (TIOCGETC) */
782 #endif /* ! defined (HAVE_TERMIOS) */
785 /* Set the logical window size associated with descriptor FD
786 to HEIGHT and WIDTH. This is used mainly with ptys. */
789 set_window_size (int fd, int height, int width)
795 size.ws_row = height;
798 if (ioctl (fd, TIOCSWINSZ, &size) == -1)
799 return 0; /* error */
803 #elif defined (TIOCSSIZE)
807 size.ts_lines = height;
808 size.ts_cols = width;
810 if (ioctl (fd, TIOCGSIZE, &size) == -1)
821 /* Set up the proper status flags for use of a pty. */
826 /* I'm told that TOICREMOTE does not mean control chars
827 "can't be sent" but rather that they don't have
828 input-editing or signaling effects.
829 That should be good, because we have other ways
830 to do those things in Emacs.
831 However, telnet mode seems not to work on 4.2.
832 So TIOCREMOTE is turned off now. */
834 /* Under hp-ux, if TIOCREMOTE is turned on, some calls
835 will hang. In particular, the "timeout" feature (which
836 causes a read to return if there is no data available)
837 does this. Also it is known that telnet mode will hang
838 in such a way that Emacs must be stopped (perhaps this
839 is the same problem).
841 If TIOCREMOTE is turned off, then there is a bug in
842 hp-ux which sometimes loses data. Apparently the
843 code which blocks the master process when the internal
844 buffer fills up does not work. Other than this,
845 though, everything else seems to work fine.
847 Since the latter lossage is more benign, we may as well
848 lose that way. -- cph */
849 #if defined (FIONBIO) && defined (SYSV_PTYS)
852 ioctl (fd, FIONBIO, &on);
856 /* On AIX, the parent gets SIGHUP when a pty attached child dies. So, we */
857 /* ignore SIGHUP once we've started a child on a pty. Note that this may */
858 /* cause EMACS not to die when it should, i.e., when its own controlling */
859 /* tty goes away. I've complained to the AIX developers, and they may */
860 /* change this behavior, but I'm not going to hold my breath. */
861 signal (SIGHUP, SIG_IGN);
864 /* In some systems (Linux through 2.0.0, at least), packet mode doesn't
865 get cleared when a pty is closed, so we need to clear it here.
866 Linux pre2.0.13 contained an attempted fix for this (from Ted Ts'o,
867 tytso@mit.edu), but apparently it messed up rlogind and telnetd, so he
868 removed the fix in pre2.0.14. - dkindred@cs.cmu.edu
872 ioctl (fd, TIOCPKT, (char *)&off);
876 #endif /* HAVE_PTYS */
879 /************************************************************************/
881 /************************************************************************/
883 /* ------------------------------------------------------ */
885 /* ------------------------------------------------------ */
887 /* It really makes more sense for the baud-rate to be console-specific
888 and not device-specific, but it's (at least potentially) used for output
892 init_baud_rate (struct device *d)
894 struct console *con = XCONSOLE (DEVICE_CONSOLE (d));
895 if (DEVICE_WIN_P (d) || DEVICE_STREAM_P (d))
897 DEVICE_BAUD_RATE (d) = 38400;
902 assert (DEVICE_TTY_P (d));
904 int input_fd = CONSOLE_TTY_DATA (con)->infd;
905 #if defined (WINDOWSNT)
906 DEVICE_TTY_DATA (d)->ospeed = 15;
907 #elif defined (HAVE_TERMIOS)
911 tcgetattr (input_fd, &sg);
912 DEVICE_TTY_DATA (d)->ospeed = cfgetospeed (&sg);
913 # if defined (USE_GETOBAUD) && defined (getobaud)
914 /* m88k-motorola-sysv3 needs this (ghazi@noc.rutgers.edu) 9/1/94. */
915 if (DEVICE_TTY_DATA (d)->ospeed == 0)
916 DEVICE_TTY_DATA (d)->ospeed = getobaud (sg.c_cflag);
918 #elif defined (HAVE_TERMIO)
923 tcgetattr (input_fd, &sg);
925 ioctl (input_fd, TCGETA, &sg);
927 DEVICE_TTY_DATA (d)->ospeed = sg.c_cflag & CBAUD;
928 #else /* neither TERMIOS nor TERMIO */
931 sg.sg_ospeed = B9600;
932 if (ioctl (input_fd, TIOCGETP, &sg) < 0)
934 DEVICE_TTY_DATA (d)->ospeed = sg.sg_ospeed;
938 DEVICE_BAUD_RATE (d) =
939 (DEVICE_TTY_DATA (d)->ospeed < countof (baud_convert)
940 ? baud_convert[DEVICE_TTY_DATA (d)->ospeed]
943 if (DEVICE_BAUD_RATE (d) == 0)
944 DEVICE_BAUD_RATE (d) = 1200;
945 #endif /* HAVE_TTY */
949 /* ------------------------------------------------------ */
951 /* ------------------------------------------------------ */
953 #if defined(SIGIO) && !defined(BROKEN_SIGIO)
956 init_sigio_on_device (struct device *d)
958 int filedesc = DEVICE_INFD (d);
960 #if defined (FIOSSAIOOWN)
962 int owner = getpid ();
964 if (DEVICE_TTY_P (d))
966 ioctl_status = ioctl (filedesc, FIOGSAIOOWN,
967 &DEVICE_OLD_FCNTL_OWNER (d));
968 ioctl_status = ioctl (filedesc, FIOSSAIOOWN, &owner);
970 #ifdef HAVE_WINDOW_SYSTEM
971 else if (!DEVICE_STREAM_P (d))
973 ioctl_status = ioctl (filedesc, SIOCGPGRP,
974 &DEVICE_OLD_FCNTL_OWNER (d));
975 ioctl_status = ioctl (filedesc, SIOCSPGRP, &owner);
979 #elif defined (F_SETOWN) && !defined (F_SETOWN_BUG)
980 DEVICE_OLD_FCNTL_OWNER (d) = fcntl (filedesc, F_GETOWN, 0);
981 # ifdef F_SETOWN_SOCK_NEG
982 /* stdin is a socket here */
983 fcntl (filedesc, F_SETOWN, -getpid ());
985 fcntl (filedesc, F_SETOWN, getpid ());
991 reset_sigio_on_device (struct device *d)
993 int filedesc = DEVICE_INFD (d);
995 #if defined (FIOSSAIOOWN)
998 if (DEVICE_TTY_P (d))
1000 ioctl_status = ioctl (filedesc, FIOSSAIOOWN,
1001 &DEVICE_OLD_FCNTL_OWNER (d));
1003 #ifdef HAVE_WINDOW_SYSTEM
1004 else if (!DEVICE_STREAM_P (d))
1006 ioctl_status = ioctl (filedesc, SIOCSPGRP,
1007 &DEVICE_OLD_FCNTL_OWNER (d));
1011 #elif defined (F_SETOWN) && !defined (F_SETOWN_BUG)
1012 fcntl (filedesc, F_SETOWN, DEVICE_OLD_FCNTL_OWNER (d));
1017 request_sigio_on_device (struct device *d)
1019 int filedesc = DEVICE_INFD (d);
1021 #if defined (I_SETSIG) && !defined(HPUX10) && !defined(LINUX)
1024 ioctl (filedesc, I_GETSIG, &events);
1025 ioctl (filedesc, I_SETSIG, events | S_INPUT);
1027 #elif defined (FASYNC)
1028 fcntl (filedesc, F_SETFL, fcntl (filedesc, F_GETFL, 0) | FASYNC);
1029 #elif defined (FIOSSAIOSTAT)
1031 /* DG: Changed for HP-UX. HP-UX uses different IOCTLs for
1032 sockets and other devices for some bizarre reason. We guess
1033 that an X device is a socket, and tty devices aren't. We then
1034 use the following crud to do the appropriate thing. */
1036 int ioctl_status; /* ####DG: check if IOCTL succeeds here. */
1038 if (DEVICE_TTY_P (d))
1040 ioctl_status = ioctl (filedesc, FIOSSAIOSTAT, &on);
1042 #ifdef HAVE_WINDOW_SYSTEM
1043 else if (!DEVICE_STREAM_P (d))
1045 ioctl_status = ioctl (filedesc, FIOASYNC, &on);
1049 #elif defined (FIOASYNC)
1052 ioctl (filedesc, FIOASYNC, &on);
1056 #if defined (_CX_UX) /* #### Is this crap necessary? */
1057 EMACS_UNBLOCK_SIGNAL (SIGIO);
1062 unrequest_sigio_on_device (struct device *d)
1064 int filedesc = DEVICE_INFD (d);
1066 #if defined (I_SETSIG) && !defined(HPUX10)
1069 ioctl (filedesc, I_GETSIG, &events);
1070 ioctl (filedesc, I_SETSIG, events & ~S_INPUT);
1072 #elif defined (FASYNC)
1073 fcntl (filedesc, F_SETFL, fcntl (filedesc, F_GETFL, 0) & ~FASYNC);
1074 #elif defined (FIOSSAIOSTAT)
1076 /* DG: Changed for HP-UX. HP-UX uses different IOCTLs for
1077 sockets and other devices for some bizarre reason. We guess
1078 that an X device is a socket, and tty devices aren't. We then
1079 use the following crud to do the appropriate thing. */
1084 /* See comment for request_sigio_on_device */
1086 if (DEVICE_TTY_P (d))
1088 ioctl_status = ioctl (filedesc, FIOSSAIOSTAT, &off);
1092 ioctl_status = ioctl (filedesc, FIOASYNC, &off);
1095 #elif defined (FIOASYNC)
1098 ioctl (filedesc, FIOASYNC, &off);
1104 request_sigio (void)
1106 Lisp_Object devcons, concons;
1108 DEVICE_LOOP_NO_BREAK (devcons, concons)
1112 d = XDEVICE (XCAR (devcons));
1114 if (!DEVICE_STREAM_P (d))
1115 request_sigio_on_device (d);
1120 unrequest_sigio (void)
1122 Lisp_Object devcons, concons;
1124 DEVICE_LOOP_NO_BREAK (devcons, concons)
1128 d = XDEVICE (XCAR (devcons));
1130 if (!DEVICE_STREAM_P (d))
1131 unrequest_sigio_on_device (d);
1137 /* ------------------------------------------------------ */
1138 /* Changing Emacs's process group */
1139 /* ------------------------------------------------------ */
1141 /* Saving and restoring the process group of Emacs's terminal. */
1143 /* On some systems, apparently (?!) Emacs must be in its own process
1144 group in order to receive SIGIO correctly. On other systems
1145 (e.g. Solaris), it's not required and doing it makes things
1146 get fucked up. So, we only do it when
1147 SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP is defined. Basically,
1148 this is only required for BSD 4.2 systems. (Actually, I bet
1149 we don't have to do this at all -- those systems also
1150 required interrupt input, which we don't support.)
1152 If Emacs was in its own process group (i.e. inherited_pgroup ==
1153 getpid ()), then we know we're running under a shell with job
1154 control (Emacs would never be run as part of a pipeline).
1157 If Emacs was not in its own process group, then we know we're
1158 running under a shell (or a caller) that doesn't know how to
1159 separate itself from Emacs (like sh). Emacs must be in its own
1160 process group in order to receive SIGIO correctly. In this
1161 situation, we put ourselves in our own pgroup, forcibly set the
1162 tty's pgroup to our pgroup, and make sure to restore and reinstate
1163 the tty's pgroup just like any other terminal setting. If
1164 inherited_group was not the tty's pgroup, then we'll get a
1165 SIGTTmumble when we try to change the tty's pgroup, and a CONT if
1166 it goes foreground in the future, which is what should happen. */
1168 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1170 static int inherited_pgroup;
1171 static int inherited_tty_pgroup;
1176 munge_tty_process_group (void)
1178 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1182 /* Only do this munging if we have a device on the controlling
1183 terminal. See the large comment below. */
1185 if (CONSOLEP (Vcontrolling_terminal) &&
1186 CONSOLE_LIVE_P (XCONSOLE (Vcontrolling_terminal)))
1188 int fd = open ("/dev/tty", O_RDWR, 0);
1190 EMACS_BLOCK_SIGNAL (SIGTTOU);
1191 EMACS_SET_TTY_PROCESS_GROUP (fd, &me);
1192 EMACS_UNBLOCK_SIGNAL (SIGTTOU);
1198 /* Split off the foreground process group to Emacs alone.
1199 When we are in the foreground, but not started in our own process
1200 group, redirect the TTY to point to our own process group. We need
1201 to be in our own process group to receive SIGIO properly. */
1203 munge_process_groups (void)
1205 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1209 EMACS_SEPARATE_PROCESS_GROUP ();
1211 munge_tty_process_group ();
1216 unmunge_tty_process_group (void)
1218 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1220 int fd = open ("/dev/tty", O_RDWR, 0);
1221 EMACS_BLOCK_SIGNAL (SIGTTOU);
1222 EMACS_SET_TTY_PROCESS_GROUP (fd, &inherited_tty_pgroup);
1223 EMACS_UNBLOCK_SIGNAL (SIGTTOU);
1229 /* Set the tty to our original foreground group.
1230 Also restore the original process group (put us back into sh's
1231 process group), so that ^Z will suspend both us and sh. */
1233 unmunge_process_groups (void)
1235 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1239 unmunge_tty_process_group ();
1241 EMACS_SET_PROCESS_GROUP (inherited_pgroup);
1245 /* According to some old wisdom, we need to be in a separate process
1246 group for SIGIO to work correctly (at least on some systems ...).
1247 So go ahead and put ourselves into our own process group. This
1248 will fail if we're already in our own process group, but who cares.
1249 Also record whether we were in our own process group. (In general,
1250 we will already be in our own process group if we were started from
1251 a job-control shell like csh, but not if we were started from sh).
1253 If we succeeded in changing our process group, then we will no
1254 longer be in the foreground process group of our controlling
1255 terminal. Therefore, if we have a console open onto this terminal,
1256 we have to change the controlling terminal's foreground process
1257 group (otherwise we will get stopped with a SIGTTIN signal when
1258 attempting to read from the terminal). It's important,
1259 however, that we do this *only* when we have a console open onto
1260 the terminal. It's a decidedly bad idea to do so otherwise,
1261 especially if XEmacs was started from the background. */
1264 init_process_group (void)
1266 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1267 if (! noninteractive)
1269 int fd = open ("/dev/tty", O_RDWR, 0);
1270 inherited_pgroup = EMACS_GET_PROCESS_GROUP ();
1271 EMACS_GET_TTY_PROCESS_GROUP (fd, &inherited_tty_pgroup);
1273 EMACS_SEPARATE_PROCESS_GROUP ();
1279 disconnect_controlling_terminal (void)
1282 /* Controlling terminals are attached to a session.
1283 Create a new session for us; it will have no controlling
1284 terminal. This also, of course, puts us in our own
1288 /* Put us in our own process group. */
1289 EMACS_SEPARATE_PROCESS_GROUP ();
1290 # if defined (TIOCNOTTY)
1291 /* This is the older way of disconnecting the controlling
1292 terminal, on 4.3 BSD. We must open /dev/tty; using
1293 filedesc 0 is not sufficient because it could be
1294 something else (e.g. our stdin was redirected to
1298 int j = open ("/dev/tty", O_RDWR, 0);
1299 ioctl (j, TIOCNOTTY, 0);
1302 # endif /* TIOCNOTTY */
1304 On systems without TIOCNOTTY and without
1305 setsid(), we don't need to do anything more to
1306 disconnect our controlling terminal. Here is
1307 what the man page for termio(7) from a SYSV 3.2
1310 "The first terminal file opened by the process group leader
1311 of a terminal file not already associated with a process
1312 group becomes the control terminal for that process group.
1313 The control terminal plays a special role in handling quit
1314 and interrupt signals, as discussed below. The control
1315 terminal is inherited by a child process during a fork(2).
1316 A process can break this association by changing its process
1317 group using setpgrp(2)."
1320 # endif /* not HAVE_SETSID */
1324 /* ------------------------------------------------------ */
1325 /* Getting and setting emacs_tty structures */
1326 /* ------------------------------------------------------ */
1328 /* It's wrong to encase these into #ifdef HAVE_TTY because we need
1329 them for child TTY processes. */
1330 /* However, this does break NT support while we don't do child TTY processes */
1333 /* Set *TC to the parameters associated with the terminal FD.
1334 Return zero if all's well, or -1 if we ran into an error we
1335 couldn't deal with. */
1337 emacs_get_tty (int fd, struct emacs_tty *settings)
1339 /* Retrieve the primary parameters - baud rate, character size, etcetera. */
1341 /* We have those nifty POSIX tcmumbleattr functions. */
1342 if (tcgetattr (fd, &settings->main) < 0)
1345 #elif defined HAVE_TERMIO
1346 /* The SYSV-style interface? */
1347 if (ioctl (fd, TCGETA, &settings->main) < 0)
1350 #elif !defined (WINDOWSNT)
1351 /* I give up - I hope you have the BSD ioctls. */
1352 if (ioctl (fd, TIOCGETP, &settings->main) < 0)
1354 #endif /* HAVE_TCATTR */
1356 /* Suivant - Do we have to get struct ltchars data? */
1358 if (ioctl (fd, TIOCGLTC, &settings->ltchars) < 0)
1362 /* How about a struct tchars and a wordful of lmode bits? */
1364 if (ioctl (fd, TIOCGETC, &settings->tchars) < 0
1365 || ioctl (fd, TIOCLGET, &settings->lmode) < 0)
1369 /* We have survived the tempest. */
1373 /* Set the parameters of the tty on FD according to the contents of
1374 *SETTINGS. If FLUSHP is non-zero, we discard input.
1375 Return 0 if all went well, and -1 if anything failed. */
1378 emacs_set_tty (int fd, struct emacs_tty *settings, int flushp)
1380 /* Set the primary parameters - baud rate, character size, etcetera. */
1383 /* We have those nifty POSIX tcmumbleattr functions.
1384 William J. Smith <wjs@wiis.wang.com> writes:
1385 "POSIX 1003.1 defines tcsetattr() to return success if it was
1386 able to perform any of the requested actions, even if some
1387 of the requested actions could not be performed.
1388 We must read settings back to ensure tty setup properly.
1389 AIX requires this to keep tty from hanging occasionally." */
1390 /* This makes sure that we don't loop indefinitely in here. */
1391 for (i = 0 ; i < 10 ; i++)
1392 if (tcsetattr (fd, flushp ? TCSAFLUSH : TCSADRAIN, &settings->main) < 0)
1403 /* Get the current settings, and see if they're what we asked for. */
1404 tcgetattr (fd, &new);
1405 /* We cannot use memcmp on the whole structure here because under
1406 * aix386 the termios structure has some reserved field that may
1409 if ( new.c_iflag == settings->main.c_iflag
1410 && new.c_oflag == settings->main.c_oflag
1411 && new.c_cflag == settings->main.c_cflag
1412 && new.c_lflag == settings->main.c_lflag
1413 && memcmp(new.c_cc, settings->main.c_cc, NCCS) == 0)
1418 #elif defined HAVE_TERMIO
1419 /* The SYSV-style interface? */
1420 if (ioctl (fd, flushp ? TCSETAF : TCSETAW, &settings->main) < 0)
1423 #elif !defined (WINDOWSNT)
1424 /* I give up - I hope you have the BSD ioctls. */
1425 if (ioctl (fd, (flushp) ? TIOCSETP : TIOCSETN, &settings->main) < 0)
1427 #endif /* HAVE_TCATTR */
1429 /* Suivant - Do we have to get struct ltchars data? */
1431 if (ioctl (fd, TIOCSLTC, &settings->ltchars) < 0)
1435 /* How about a struct tchars and a wordful of lmode bits? */
1437 if (ioctl (fd, TIOCSETC, &settings->tchars) < 0
1438 || ioctl (fd, TIOCLSET, &settings->lmode) < 0)
1442 /* We have survived the tempest. */
1446 #endif /* WINDOWSNT */
1448 /* ------------------------------------------------------ */
1449 /* Initializing a device */
1450 /* ------------------------------------------------------ */
1454 /* This may also be defined in stdio,
1455 but if so, this does no harm,
1456 and using the same name avoids wasting the other one's space. */
1458 #if ((defined(USG) || defined(DGUX)) && !defined(__STDC__))
1459 char _sobuf[BUFSIZ+8];
1460 #elif (defined(USG) && !defined(LINUX) && !defined(_SCO_DS)) || defined(IRIX5)
1461 extern unsigned char _sobuf[BUFSIZ+8];
1463 char _sobuf[BUFSIZ];
1466 #if defined (TIOCGLTC) && defined (HAVE_LTCHARS) /* HAVE_LTCHARS */
1467 static struct ltchars new_ltchars = {-1,-1,-1,-1,-1,-1};
1469 #ifdef TIOCGETC /* HAVE_TCHARS */
1471 static struct tchars new_tchars = {-1,-1,-1,-1,-1,-1};
1476 tty_init_sys_modes_on_device (struct device *d)
1478 struct emacs_tty tty;
1479 int input_fd, output_fd;
1480 struct console *con = XCONSOLE (DEVICE_CONSOLE (d));
1482 input_fd = CONSOLE_TTY_DATA (con)->infd;
1483 output_fd = CONSOLE_TTY_DATA (con)->outfd;
1485 EMACS_GET_TTY (input_fd, &CONSOLE_TTY_DATA (con)->old_tty);
1486 tty = CONSOLE_TTY_DATA (con)->old_tty;
1488 con->tty_erase_char = Qnil;
1490 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
1491 /* after all those years... */
1492 con->tty_erase_char = make_char (tty.main.c_cc[VERASE]);
1494 /* This allows meta to be sent on 8th bit. */
1495 tty.main.c_iflag &= ~INPCK; /* don't check input for parity */
1497 tty.main.c_iflag |= (IGNBRK); /* Ignore break condition */
1498 tty.main.c_iflag &= ~ICRNL; /* Disable map of CR to NL on input */
1500 tty.main.c_iflag &= ~ISTRIP; /* don't strip 8th bit on input */
1502 tty.main.c_lflag &= ~ECHO; /* Disable echo */
1503 tty.main.c_lflag &= ~ICANON; /* Disable erase/kill processing */
1505 tty.main.c_lflag &= ~IEXTEN; /* Disable other editing characters. */
1507 tty.main.c_lflag |= ISIG; /* Enable signals */
1508 if (TTY_FLAGS (con).flow_control)
1510 tty.main.c_iflag |= IXON; /* Enable start/stop output control */
1512 tty.main.c_iflag &= ~IXANY;
1516 tty.main.c_iflag &= ~IXON; /* Disable start/stop output control */
1517 tty.main.c_oflag &= ~ONLCR; /* Disable map of NL to CR-NL
1519 tty.main.c_oflag &= ~TAB3; /* Disable tab expansion */
1521 if (TTY_FLAGS (con).meta_key)
1523 tty.main.c_cflag |= CS8; /* allow 8th bit on input */
1524 tty.main.c_cflag &= ~PARENB;/* Don't check parity */
1527 if (CONSOLE_TTY_DATA (con)->controlling_terminal)
1529 tty.main.c_cc[VINTR] =
1530 CONSOLE_QUIT_CHAR (con); /* C-g (usually) gives SIGINT */
1531 /* Set up C-g for both SIGQUIT and SIGINT.
1532 We don't know which we will get, but we handle both alike
1533 so which one it really gives us does not matter. */
1534 tty.main.c_cc[VQUIT] = CONSOLE_QUIT_CHAR (con);
1538 tty.main.c_cc[VINTR] = _POSIX_VDISABLE;
1539 tty.main.c_cc[VQUIT] = _POSIX_VDISABLE;
1541 tty.main.c_cc[VMIN] = 1; /* Input should wait for at
1543 tty.main.c_cc[VTIME] = 0; /* no matter how long that takes. */
1545 tty.main.c_cc[VSWTCH] = _POSIX_VDISABLE; /* Turn off shell layering use
1548 /* There was some conditionalizing here on (mips or TCATTR), but
1549 I think that's wrong. There was one report of C-y (DSUSP) not being
1550 disabled on HP9000s700 systems, and this might fix it. */
1552 tty.main.c_cc[VSUSP] = _POSIX_VDISABLE; /* Turn off mips handling of C-z. */
1555 tty.main.c_cc[V_DSUSP] = _POSIX_VDISABLE; /* Turn off mips handling of C-y. */
1556 #endif /* V_DSUSP */
1557 #ifdef VDSUSP /* Some systems have VDSUSP, some have V_DSUSP. */
1558 tty.main.c_cc[VDSUSP] = _POSIX_VDISABLE;
1561 tty.main.c_cc[VLNEXT] = _POSIX_VDISABLE;
1564 tty.main.c_cc[VREPRINT] = _POSIX_VDISABLE;
1565 #endif /* VREPRINT */
1567 tty.main.c_cc[VWERASE] = _POSIX_VDISABLE;
1568 #endif /* VWERASE */
1570 tty.main.c_cc[VDISCARD] = _POSIX_VDISABLE;
1571 #endif /* VDISCARD */
1573 tty.main.c_cc[VSTART] = _POSIX_VDISABLE;
1576 tty.main.c_cc[VSTRT] = _POSIX_VDISABLE; /* called VSTRT on some systems */
1579 tty.main.c_cc[VSTOP] = _POSIX_VDISABLE;
1581 #ifdef SET_LINE_DISCIPLINE
1582 /* Need to explicitly request TERMIODISC line discipline or
1583 Ultrix's termios does not work correctly. */
1584 tty.main.c_line = SET_LINE_DISCIPLINE;
1589 /* AIX enhanced edit loses NULs, so disable it. */
1590 tty.main.c_line = 0;
1591 tty.main.c_iflag &= ~ASCEDIT;
1593 tty.main.c_cc[VSTRT] = 255;
1594 tty.main.c_cc[VSTOP] = 255;
1595 tty.main.c_cc[VSUSP] = 255;
1596 tty.main.c_cc[VDSUSP] = 255;
1597 #endif /* IBMR2AIX */
1598 /* Also, PTY overloads NUL and BREAK.
1599 don't ignore break, but don't signal either, so it looks like NUL.
1600 This really serves a purpose only if running in an XTERM window
1601 or via TELNET or the like, but does no harm elsewhere. */
1602 tty.main.c_iflag &= ~IGNBRK;
1603 tty.main.c_iflag &= ~BRKINT;
1605 #else /* if not HAVE_TERMIO */
1606 #if !defined (WINDOWSNT)
1607 con->tty_erase_char = make_char (tty.main.sg_erase);
1608 tty.main.sg_flags &= ~(ECHO | CRMOD | XTABS);
1609 if (TTY_FLAGS (con).meta_key)
1610 tty.main.sg_flags |= ANYP;
1611 /* #### should we be using RAW mode here? */
1612 tty.main.sg_flags |= /* interrupt_input ? RAW : */ CBREAK;
1613 #endif /* not WINDOWSNT */
1614 #endif /* not HAVE_TERMIO */
1616 /* If going to use CBREAK mode, we must request C-g to interrupt
1617 and turn off start and stop chars, etc. If not going to use
1618 CBREAK mode, do this anyway so as to turn off local flow
1619 control for user coming over network on 4.2; in this case,
1620 only t_stopc and t_startc really matter. */
1623 /* Note: if not using CBREAK mode, it makes no difference how we
1625 tty.tchars = new_tchars;
1626 tty.tchars.t_intrc = CONSOLE_QUIT_CHAR (con);
1627 if (TTY_FLAGS (con).flow_control)
1629 tty.tchars.t_startc = '\021';
1630 tty.tchars.t_stopc = '\023';
1633 tty.lmode = LDECCTQ | LLITOUT | LPASS8 | LNOFLSH |
1634 CONSOLE_TTY_DATA (con)->old_tty.lmode;
1636 #if defined (ultrix) || defined (__bsdi__)
1637 /* Under Ultrix 4.2a, leaving this out doesn't seem to hurt
1638 anything, and leaving it in breaks the meta key. Go figure. */
1639 /* Turning off ONLCR is enough under BSD/386. Leave the general
1640 output post-processing flag alone since for some reason it
1641 doesn't get reset after XEmacs goes away. */
1642 tty.lmode &= ~LLITOUT;
1645 #endif /* HAVE_TCHARS */
1646 #endif /* not HAVE_TERMIO */
1649 tty.ltchars = new_ltchars;
1650 #endif /* HAVE_LTCHARS */
1652 EMACS_SET_TTY (input_fd, &tty, 0);
1654 /* This code added to insure that, if flow-control is not to be used,
1655 we have an unlocked terminal at the start. */
1658 if (!TTY_FLAGS (con).flow_control) ioctl (input_fd, TCXONC, 1);
1662 if (!TTY_FLAGS (con).flow_control) ioctl (input_fd, TIOCSTART, 0);
1666 #if defined (HAVE_TERMIOS) || defined (HPUX9)
1668 if (!TTY_FLAGS (con).flow_control) tcflow (input_fd, TCOON);
1675 /* IBM's HFT device usually thinks a ^J should be LF/CR.
1676 We need it to be only LF. This is the way that is
1680 if (ioctl (output_fd, HFTGETID, &tty) != -1)
1681 write (output_fd, "\033[20l", 5);
1686 #if 0 /* We do our own buffering with lstreams. */
1688 /* This symbol is defined on recent USG systems.
1689 Someone says without this call USG won't really buffer the file
1690 even with a call to setbuf. */
1691 setvbuf (CONSOLE_TTY_DATA (con)->outfd, (char *) _sobuf, _IOFBF, sizeof _sobuf);
1693 setbuf (CONSOLE_TTY_DATA (con)->outfd, (char *) _sobuf);
1696 set_tty_modes (con);
1699 #endif /* HAVE_TTY */
1702 init_one_device (struct device *d)
1705 if (DEVICE_TTY_P (d))
1706 tty_init_sys_modes_on_device (d);
1708 #if defined(SIGIO) && !defined(BROKEN_SIGIO)
1709 if (!DEVICE_STREAM_P (d))
1711 init_sigio_on_device (d);
1712 request_sigio_on_device (d);
1718 init_one_console (struct console *con)
1720 Lisp_Object devcons;
1722 CONSOLE_DEVICE_LOOP (devcons, con)
1724 struct device *d = XDEVICE (XCAR (devcons));
1726 init_one_device (d);
1731 reinit_initial_console (void)
1733 munge_process_groups ();
1734 if (CONSOLEP (Vcontrolling_terminal) &&
1735 CONSOLE_LIVE_P (XCONSOLE (Vcontrolling_terminal)))
1736 init_one_console (XCONSOLE (Vcontrolling_terminal));
1740 /* ------------------------------------------------------ */
1741 /* Other TTY functions */
1742 /* ------------------------------------------------------ */
1746 #if 0 /* not currently used */
1748 /* Return nonzero if safe to use tabs in output.
1749 At the time this is called, init_sys_modes has not been done yet. */
1752 tabs_safe_p (struct device *d)
1755 if (DEVICE_TTY_P (d))
1757 struct emacs_tty tty;
1759 EMACS_GET_TTY (DEVICE_INFD (d), &tty);
1760 return EMACS_TTY_TABS_OK (&tty);
1768 /* Get terminal size from system.
1769 Store number of lines into *heightp and width into *widthp.
1770 If zero or a negative number is stored, the value is not valid. */
1773 get_tty_device_size (struct device *d, int *widthp, int *heightp)
1775 int input_fd = DEVICE_INFD (d);
1777 assert (DEVICE_TTY_P (d));
1782 struct winsize size;
1784 if (ioctl (input_fd, TIOCGWINSZ, &size) == -1)
1785 *widthp = *heightp = 0;
1788 *widthp = size.ws_col;
1789 *heightp = size.ws_row;
1792 #elif defined TIOCGSIZE
1794 /* SunOS - style. */
1795 struct ttysize size;
1797 if (ioctl (input_fd, TIOCGSIZE, &size) == -1)
1798 *widthp = *heightp = 0;
1801 *widthp = size.ts_cols;
1802 *heightp = size.ts_lines;
1805 #else /* system doesn't know size */
1810 #endif /* not !TIOCGWINSZ */
1813 #endif /* HAVE_TTY */
1816 /* ------------------------------------------------------ */
1817 /* Is device 8 bit ? */
1818 /* ------------------------------------------------------ */
1823 eight_bit_tty (struct device *d)
1829 assert (DEVICE_TTY_P (d));
1830 input_fd = DEVICE_INFD (d);
1832 EMACS_GET_TTY (input_fd, &s);
1834 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
1835 eight_bit = (s.main.c_cflag & CSIZE) == CS8;
1837 eight_bit = 0; /* I don't know how to do it */
1842 #endif /* HAVE_TTY */
1845 /* ------------------------------------------------------ */
1846 /* Resetting a device */
1847 /* ------------------------------------------------------ */
1851 /* Prepare the terminal for exiting Emacs; move the cursor to the
1852 bottom of the frame, turn off interrupt-driven I/O, etc. */
1854 tty_reset_sys_modes_on_device (struct device *d)
1856 int input_fd, output_fd;
1857 struct console *con = XCONSOLE (DEVICE_CONSOLE (d));
1859 input_fd = CONSOLE_TTY_DATA (con)->infd;
1860 output_fd = CONSOLE_TTY_DATA (con)->outfd;
1862 #if defined (IBMR2AIX) && defined (AIXHFT)
1864 /* HFT consoles normally use ^J as a LF/CR. We forced it to
1865 do the LF only. Now, we need to reset it. */
1868 if (ioctl (output_fd, HFTGETID, &tty) != -1)
1869 write (output_fd, "\033[20h", 5);
1873 tty_redisplay_shutdown (con);
1874 /* reset_tty_modes() flushes the connection at its end. */
1875 reset_tty_modes (con);
1878 /* Avoid possible loss of output when changing terminal modes. */
1882 while (EMACS_SET_TTY (input_fd, &CONSOLE_TTY_DATA (con)->old_tty, 0)
1883 < 0 && errno == EINTR)
1886 #ifdef SET_LINE_DISCIPLINE
1887 /* Ultrix's termios *ignores* any line discipline except TERMIODISC.
1888 A different old line discipline is therefore not restored, yet.
1889 Restore the old line discipline by hand. */
1890 ioctl (input_fd, TIOCSETD, &old_tty.main.c_line);
1899 #endif /* HAVE_TTY */
1902 reset_one_device (struct device *d)
1905 if (DEVICE_TTY_P (d))
1906 tty_reset_sys_modes_on_device (d);
1909 if (DEVICE_STREAM_P (d))
1910 fflush (CONSOLE_STREAM_DATA (XCONSOLE (DEVICE_CONSOLE (d)))->out);
1911 #if defined(SIGIO) && !defined(BROKEN_SIGIO)
1912 if (!DEVICE_STREAM_P (d))
1914 unrequest_sigio_on_device (d);
1915 reset_sigio_on_device (d);
1921 reset_one_console (struct console *con)
1923 /* Note: this can be called during GC. */
1924 Lisp_Object devcons;
1926 CONSOLE_DEVICE_LOOP (devcons, con)
1928 struct device *d = XDEVICE (XCAR (devcons));
1930 reset_one_device (d);
1935 reset_all_consoles (void)
1937 /* Note: this can be called during GC. */
1938 Lisp_Object concons;
1940 CONSOLE_LOOP (concons)
1942 struct console *con = XCONSOLE (XCAR (concons));
1944 reset_one_console (con);
1947 unmunge_process_groups ();
1951 reset_initial_console (void)
1953 if (CONSOLEP (Vcontrolling_terminal) &&
1954 CONSOLE_LIVE_P (XCONSOLE (Vcontrolling_terminal)))
1955 reset_one_console (XCONSOLE (Vcontrolling_terminal));
1956 unmunge_process_groups ();
1960 /* ------------------------------------------------------ */
1961 /* extra TTY stuff under AIX */
1962 /* ------------------------------------------------------ */
1966 /* Called from init_sys_modes. */
1968 hft_init (struct console *con)
1973 assert (CONSOLE_TTY_P (con));
1974 input_fd = CONSOLE_TTY_DATA (con)->infd;
1976 /* If we're not on an HFT we shouldn't do any of this. We determine
1977 if we are on an HFT by trying to get an HFT error code. If this
1978 call fails, we're not on an HFT. */
1980 if (ioctl (input_fd, HFQERROR, &junk) < 0)
1982 #else /* not IBMR2AIX */
1983 if (ioctl (input_fd, HFQEIO, 0) < 0)
1985 #endif /* not IBMR2AIX */
1987 /* On AIX the default hft keyboard mapping uses backspace rather than delete
1988 as the rubout key's ASCII code. Here this is changed. The bug is that
1989 there's no way to determine the old mapping, so in reset_one_console
1990 we need to assume that the normal map had been present. Of course, this
1991 code also doesn't help if on a terminal emulator which doesn't understand
1995 struct hfkeymap keymap;
1997 buf.hf_bufp = (char *)&keymap;
1998 buf.hf_buflen = sizeof (keymap);
1999 keymap.hf_nkeys = 2;
2000 keymap.hfkey[0].hf_kpos = 15;
2001 keymap.hfkey[0].hf_kstate = HFMAPCHAR | HFSHFNONE;
2003 keymap.hfkey[0].hf_keyidh = '<';
2004 #else /* not IBMR2AIX */
2005 keymap.hfkey[0].hf_page = '<';
2006 #endif /* not IBMR2AIX */
2007 keymap.hfkey[0].hf_char = 127;
2008 keymap.hfkey[1].hf_kpos = 15;
2009 keymap.hfkey[1].hf_kstate = HFMAPCHAR | HFSHFSHFT;
2011 keymap.hfkey[1].hf_keyidh = '<';
2012 #else /* not IBMR2AIX */
2013 keymap.hfkey[1].hf_page = '<';
2014 #endif /* not IBMR2AIX */
2015 keymap.hfkey[1].hf_char = 127;
2016 hftctl (input_fd, HFSKBD, &buf);
2018 /* #### Should probably set a console TTY flag here. */
2020 /* The HFT system on AIX doesn't optimize for scrolling, so it's really ugly
2022 line_ins_del_ok = char_ins_del_ok = 0;
2026 /* Reset the rubout key to backspace. */
2029 hft_reset (struct console *con)
2032 struct hfkeymap keymap;
2036 assert (CONSOLE_TTY_P (con));
2037 input_fd = CONSOLE_TTY_DATA (con)->infd;
2040 if (ioctl (input_fd, HFQERROR, &junk) < 0)
2042 #else /* not IBMR2AIX */
2043 if (ioctl (input_fd, HFQEIO, 0) < 0)
2045 #endif /* not IBMR2AIX */
2047 buf.hf_bufp = (char *)&keymap;
2048 buf.hf_buflen = sizeof (keymap);
2049 keymap.hf_nkeys = 2;
2050 keymap.hfkey[0].hf_kpos = 15;
2051 keymap.hfkey[0].hf_kstate = HFMAPCHAR | HFSHFNONE;
2053 keymap.hfkey[0].hf_keyidh = '<';
2054 #else /* not IBMR2AIX */
2055 keymap.hfkey[0].hf_page = '<';
2056 #endif /* not IBMR2AIX */
2057 keymap.hfkey[0].hf_char = 8;
2058 keymap.hfkey[1].hf_kpos = 15;
2059 keymap.hfkey[1].hf_kstate = HFMAPCHAR | HFSHFSHFT;
2061 keymap.hfkey[1].hf_keyidh = '<';
2062 #else /* not IBMR2AIX */
2063 keymap.hfkey[1].hf_page = '<';
2064 #endif /* not IBMR2AIX */
2065 keymap.hfkey[1].hf_char = 8;
2066 hftctl (input_fd, HFSKBD, &buf);
2072 /************************************************************************/
2073 /* limits of text/data segments */
2074 /************************************************************************/
2080 #ifndef SYSTEM_MALLOC
2087 /* Some systems that cannot dump also cannot implement these. */
2090 * Return the address of the start of the text segment prior to
2091 * doing an unexec. After unexec the return value is undefined.
2092 * See crt0.c for further explanation and _start.
2097 extern "C" int _start ();
2099 extern int _start ();
2102 #ifndef HAVE_TEXT_START
2104 start_of_text (void)
2107 return ((char *) TEXT_START);
2111 return ((char *) csrt);
2112 #else /* not GOULD */
2113 return ((char *) _start);
2115 #endif /* TEXT_START */
2117 #endif /* not HAVE_TEXT_START */
2120 * Return the address of the start of the data segment prior to
2121 * doing an unexec. After unexec the return value is undefined.
2122 * See crt0.c for further information and definition of data_start.
2124 * Apparently, on BSD systems this is etext at startup. On
2125 * USG systems (swapping) this is highly mmu dependent and
2126 * is also dependent on whether or not the program is running
2127 * with shared text. Generally there is a (possibly large)
2128 * gap between end of text and start of data with shared text.
2130 * On Uniplus+ systems with shared text, data starts at a
2131 * fixed address. Each port (from a given oem) is generally
2132 * different, and the specific value of the start of data can
2133 * be obtained via the UniPlus+ specific "uvar" system call,
2134 * however the method outlined in crt0.c seems to be more portable.
2136 * Probably what will have to happen when a USG unexec is available,
2137 * at least on UniPlus, is temacs will have to be made unshared so
2138 * that text and data are contiguous. Then once loadup is complete,
2139 * unexec will produce a shared executable where the data can be
2140 * at the normal shared text boundary and the startofdata variable
2141 * will be patched by unexec to the correct value.
2145 #ifdef ORDINARY_LINK
2146 extern char **environ;
2150 start_of_data (void)
2153 return ((char *) DATA_START);
2155 #ifdef ORDINARY_LINK
2157 * This is a hack. Since we're not linking crt0.c or pre_crt0.c,
2158 * data_start isn't defined. We take the address of environ, which
2159 * is known to live at or near the start of the system crt0.c, and
2160 * we don't sweat the handful of bytes that might lose.
2163 extern char* static_heap_base;
2165 return static_heap_base;
2167 return((char *) &environ);
2169 extern int data_start;
2170 return ((char *) &data_start);
2171 #endif /* ORDINARY_LINK */
2172 #endif /* DATA_START */
2174 #endif /* NEED_STARTS (not CANNOT_DUMP or not SYSTEM_MALLOC) */
2177 /* Some systems that cannot dump also cannot implement these. */
2180 * Return the address of the end of the text segment prior to
2181 * doing an unexec. After unexec the return value is undefined.
2188 return ((char *) TEXT_END);
2191 return ((char *) &etext);
2196 * Return the address of the end of the data segment prior to
2197 * doing an unexec. After unexec the return value is undefined.
2204 return ((char *) DATA_END);
2207 return ((char *) &edata);
2211 #endif /* not CANNOT_DUMP */
2214 /************************************************************************/
2215 /* get the system name */
2216 /************************************************************************/
2218 /* init_system_name sets up the string for the Lisp function
2219 system-name to return. */
2221 extern Lisp_Object Vsystem_name;
2224 # include <sys/socket.h>
2226 #endif /* HAVE_SOCKETS */
2229 init_system_name (void)
2231 #if defined (WINDOWSNT)
2232 char hostname [MAX_COMPUTERNAME_LENGTH + 1];
2233 size_t size = sizeof(hostname);
2234 GetComputerName (hostname, &size);
2235 Vsystem_name = build_string (hostname);
2236 #elif !defined (HAVE_GETHOSTNAME)
2239 Vsystem_name = build_string (uts.nodename);
2240 #else /* HAVE_GETHOSTNAME */
2241 unsigned int hostname_size = 256;
2242 char *hostname = (char *) alloca (hostname_size);
2244 /* Try to get the host name; if the buffer is too short, try
2245 again. Apparently, the only indication gethostname gives of
2246 whether the buffer was large enough is the presence or absence
2247 of a '\0' in the string. Eech. */
2250 gethostname (hostname, hostname_size - 1);
2251 hostname[hostname_size - 1] = '\0';
2253 /* Was the buffer large enough for the '\0'? */
2254 if (strlen (hostname) < (size_t) (hostname_size - 1))
2257 hostname_size <<= 1;
2258 hostname = (char *) alloca (hostname_size);
2260 # if defined( HAVE_SOCKETS) && !defined(BROKEN_CYGWIN)
2261 /* Turn the hostname into the official, fully-qualified hostname.
2262 Don't do this if we're going to dump; this can confuse system
2263 libraries on some machines and make the dumped emacs core dump. */
2264 # ifndef CANNOT_DUMP
2266 # endif /* not CANNOT_DUMP */
2267 if (!strchr (hostname, '.'))
2269 struct hostent *hp = NULL;
2272 for (count = 0; count < 10; count++)
2276 /* Some systems can't handle SIGALARM/SIGIO in gethostbyname(). */
2278 hp = gethostbyname (hostname);
2279 start_interrupts ();
2281 if (! (hp == 0 && h_errno == TRY_AGAIN))
2283 Fsleep_for (make_int (1));
2288 CONST char *fqdn = (CONST char *) hp->h_name;
2290 if (!strchr (fqdn, '.'))
2292 /* We still don't have a fully qualified domain name.
2293 Try to find one in the list of alternate names */
2294 char **alias = hp->h_aliases;
2295 while (*alias && !strchr (*alias, '.'))
2300 hostname = (char *) alloca (strlen (fqdn) + 1);
2301 strcpy (hostname, fqdn);
2304 # endif /* HAVE_SOCKETS */
2305 Vsystem_name = build_string (hostname);
2306 #endif /* HAVE_GETHOSTNAME */
2311 for (i = 0, p = XSTRING_DATA (Vsystem_name);
2312 i < XSTRING_LENGTH (Vsystem_name);
2315 if (*p == ' ' || *p == '\t')
2322 /************************************************************************/
2323 /* Emulation of select() */
2324 /************************************************************************/
2328 ERROR: XEmacs requires a working select().
2330 #endif /* not HAVE_SELECT */
2333 /************************************************************************/
2334 /* Emulation of signal stuff */
2335 /************************************************************************/
2337 /* BSD 4.1 crap deleted. 4.2 was released in 1983, for God's sake! I
2338 can't imagine that anyone is actually running that OS any more.
2339 You can't use X under it (I think) because there's no select().
2340 Anyway, the signal stuff has all been changed. If someone wants to
2341 get this stuff working again, look in the FSF Emacs sources. */
2343 /* POSIX signals support - DJB */
2345 #ifdef HAVE_SIGPROCMASK
2347 /* #### Is there any reason this is static global rather than local? */
2348 static struct sigaction new_action, old_action;
2351 sys_do_signal (int signal_number, signal_handler_t action)
2355 /* XEmacs works better if system calls are *not* restarted.
2356 This allows C-g to interrupt reads and writes, on most systems.
2358 #### Another possibility is to just longjmp() out of the signal
2359 handler. According to W.R. Stevens, this should be OK on all
2360 systems. However, I don't want to deal with the potential
2361 evil ramifications of this at this point. */
2364 /* This gets us restartable system calls for efficiency.
2365 The "else" code will work as well. */
2366 return (berk_signal (signal_number, action));
2368 sigemptyset (&new_action.sa_mask);
2369 new_action.sa_handler = action;
2370 #if defined (SA_RESTART)
2371 /* Emacs mostly works better with restartable system services. If this
2372 * flag exists, we probably want to turn it on here.
2374 new_action.sa_flags = SA_RESTART;
2376 new_action.sa_flags = 0;
2378 sigaction (signal_number, &new_action, &old_action);
2379 return (old_action.sa_handler);
2384 sigemptyset (&new_action.sa_mask);
2385 new_action.sa_handler = action;
2386 #if defined (SA_INTERRUPT) /* don't restart system calls, under SunOS */
2387 new_action.sa_flags = SA_INTERRUPT;
2389 new_action.sa_flags = 0;
2391 sigaction (signal_number, &new_action, &old_action);
2392 return (signal_handler_t) (old_action.sa_handler);
2397 #elif defined (HAVE_SIGBLOCK)
2399 /* We use sigvec() rather than signal() if we have it, because
2400 it lets us specify interruptible system calls. */
2402 sys_do_signal (int signal_number, signal_handler_t action)
2404 struct sigvec vec, ovec;
2406 vec.sv_handler = action;
2408 #ifdef SV_INTERRUPT /* don't restart system calls */
2409 vec.sv_flags = SV_INTERRUPT;
2414 sigvec (signal_number, &vec, &ovec);
2416 return (ovec.sv_handler);
2419 #endif /* HAVE_SIGBLOCK (HAVE_SIGPROCMASK) */
2422 /************************************************************************/
2423 /* Emulation of strerror() and errno support */
2424 /************************************************************************/
2426 #ifndef HAVE_STRERROR
2428 #if !defined(NeXT) && !defined(__alpha) && !defined(MACH) && !defined(LINUX) && !defined(IRIX) && !defined(__NetBSD__)
2429 /* Linux added here by Raymond L. Toy <toy@alydar.crd.ge.com> for XEmacs. */
2430 /* Irix added here by gparker@sni-usa.com for XEmacs. */
2431 /* NetBSD added here by James R Grinter <jrg@doc.ic.ac.uk> for XEmacs */
2432 extern CONST char *sys_errlist[];
2433 extern int sys_nerr;
2437 extern char *sys_errlist[];
2438 extern int sys_nerr;
2443 strerror (int errnum)
2445 if (errnum >= 0 && errnum < sys_nerr)
2446 return sys_errlist[errnum];
2447 return ((CONST char *) GETTEXT ("Unknown error"));
2450 #endif /* ! HAVE_STRERROR */
2455 unsigned long oscode; /* Win32 error */
2456 int errnocode; /* unix errno */
2459 static struct errentry errtable[] = {
2460 { ERROR_INVALID_FUNCTION, EINVAL }, /* 1 */
2461 { ERROR_FILE_NOT_FOUND, ENOENT }, /* 2 */
2462 { ERROR_PATH_NOT_FOUND, ENOENT }, /* 3 */
2463 { ERROR_TOO_MANY_OPEN_FILES, EMFILE }, /* 4 */
2464 { ERROR_ACCESS_DENIED, EACCES }, /* 5 */
2465 { ERROR_INVALID_HANDLE, EBADF }, /* 6 */
2466 { ERROR_ARENA_TRASHED, ENOMEM }, /* 7 */
2467 { ERROR_NOT_ENOUGH_MEMORY, ENOMEM }, /* 8 */
2468 { ERROR_INVALID_BLOCK, ENOMEM }, /* 9 */
2469 { ERROR_BAD_ENVIRONMENT, E2BIG }, /* 10 */
2470 { ERROR_BAD_FORMAT, ENOEXEC }, /* 11 */
2471 { ERROR_INVALID_ACCESS, EINVAL }, /* 12 */
2472 { ERROR_INVALID_DATA, EINVAL }, /* 13 */
2473 { ERROR_INVALID_DRIVE, ENOENT }, /* 15 */
2474 { ERROR_CURRENT_DIRECTORY, EACCES }, /* 16 */
2475 { ERROR_NOT_SAME_DEVICE, EXDEV }, /* 17 */
2476 { ERROR_NO_MORE_FILES, ENOENT }, /* 18 */
2477 { ERROR_LOCK_VIOLATION, EACCES }, /* 33 */
2478 { ERROR_BAD_NETPATH, ENOENT }, /* 53 */
2479 { ERROR_NETWORK_ACCESS_DENIED, EACCES }, /* 65 */
2480 { ERROR_BAD_NET_NAME, ENOENT }, /* 67 */
2481 { ERROR_FILE_EXISTS, EEXIST }, /* 80 */
2482 { ERROR_CANNOT_MAKE, EACCES }, /* 82 */
2483 { ERROR_FAIL_I24, EACCES }, /* 83 */
2484 { ERROR_INVALID_PARAMETER, EINVAL }, /* 87 */
2485 { ERROR_NO_PROC_SLOTS, EAGAIN }, /* 89 */
2486 { ERROR_DRIVE_LOCKED, EACCES }, /* 108 */
2487 { ERROR_BROKEN_PIPE, EPIPE }, /* 109 */
2488 { ERROR_DISK_FULL, ENOSPC }, /* 112 */
2489 { ERROR_INVALID_TARGET_HANDLE, EBADF }, /* 114 */
2490 { ERROR_INVALID_HANDLE, EINVAL }, /* 124 */
2491 { ERROR_WAIT_NO_CHILDREN, ECHILD }, /* 128 */
2492 { ERROR_CHILD_NOT_COMPLETE, ECHILD }, /* 129 */
2493 { ERROR_DIRECT_ACCESS_HANDLE, EBADF }, /* 130 */
2494 { ERROR_NEGATIVE_SEEK, EINVAL }, /* 131 */
2495 { ERROR_SEEK_ON_DEVICE, EACCES }, /* 132 */
2496 { ERROR_DIR_NOT_EMPTY, ENOTEMPTY }, /* 145 */
2497 { ERROR_NOT_LOCKED, EACCES }, /* 158 */
2498 { ERROR_BAD_PATHNAME, ENOENT }, /* 161 */
2499 { ERROR_MAX_THRDS_REACHED, EAGAIN }, /* 164 */
2500 { ERROR_LOCK_FAILED, EACCES }, /* 167 */
2501 { ERROR_ALREADY_EXISTS, EEXIST }, /* 183 */
2502 { ERROR_FILENAME_EXCED_RANGE, ENOENT }, /* 206 */
2503 { ERROR_NESTING_NOT_ALLOWED, EAGAIN }, /* 215 */
2504 { ERROR_NOT_ENOUGH_QUOTA, ENOMEM } /* 1816 */
2507 /* The following two constants must be the minimum and maximum
2508 values in the (contiguous) range of Exec Failure errors. */
2509 #define MIN_EXEC_ERROR ERROR_INVALID_STARTING_CODESEG
2510 #define MAX_EXEC_ERROR ERROR_INFLOOP_IN_RELOC_CHAIN
2512 /* These are the low and high value in the range of errors that are
2513 access violations */
2514 #define MIN_EACCES_RANGE ERROR_WRITE_PROTECT
2515 #define MAX_EACCES_RANGE ERROR_SHARING_BUFFER_EXCEEDED
2518 mswindows_set_errno (unsigned long win32_error)
2522 /* check the table for the OS error code */
2523 for (i = 0; i < sizeof(errtable)/sizeof(errtable[0]); ++i)
2525 if (win32_error == errtable[i].oscode)
2527 errno = errtable[i].errnocode;
2532 /* The error code wasn't in the table. We check for a range of
2533 * EACCES errors or exec failure errors (ENOEXEC). Otherwise EINVAL is
2535 if (win32_error >= MIN_EACCES_RANGE && win32_error <= MAX_EACCES_RANGE)
2537 else if (win32_error >= MIN_EXEC_ERROR && win32_error <= MAX_EXEC_ERROR)
2544 mswindows_set_last_errno (void)
2546 mswindows_set_errno (GetLastError ());
2549 #endif /* WINDOWSNT */
2552 /************************************************************************/
2553 /* Encapsulations of system calls */
2554 /************************************************************************/
2556 #define PATHNAME_CONVERT_OUT(path) \
2557 GET_C_CHARPTR_EXT_FILENAME_DATA_ALLOCA ((CONST Bufbyte *) path, path)
2559 /***************** low-level calls ****************/
2562 * On USG systems the system calls are INTERRUPTIBLE by signals
2563 * that the user program has elected to catch. Thus the system call
2564 * must be retried in these cases. To handle this without massive
2565 * changes in the source code, we remap the standard system call names
2566 * to names for our own functions in sysdep.c that do the system call
2567 * with retries. Actually, for portability reasons, it is good
2568 * programming practice, as this example shows, to limit all actual
2569 * system calls to a single occurrence in the source. Sure, this
2570 * adds an extra level of function call overhead but it is almost
2571 * always negligible. Fred Fish, Unisoft Systems Inc.
2574 /* Ben sez: read Dick Gabriel's essay about the Worse Is Better
2575 approach to programming and its connection to the silly
2576 interruptible-system-call business. To find it, look on
2577 Jamie's home page (http://www.jwz.org/worse-is-better.html). */
2579 #ifdef ENCAPSULATE_OPEN
2581 sys_open (CONST char *path, int oflag, ...)
2586 va_start (ap, oflag);
2587 mode = va_arg (ap, int);
2590 PATHNAME_CONVERT_OUT (path);
2591 #if defined (WINDOWSNT)
2592 /* Make all handles non-inheritable */
2593 return open (path, oflag | _O_NOINHERIT, mode);
2594 #elif defined (INTERRUPTIBLE_OPEN)
2597 while ((rtnval = open (path, oflag, mode)) == -1
2598 && (errno == EINTR))
2603 return open (path, oflag, mode);
2606 #endif /* ENCAPSULATE_OPEN */
2608 /* Like sys_open, only when open() is interrupted by EINTR, check for
2609 QUIT. This allows the callers of this function to be interrupted
2610 with C-g when, say, reading from named pipes. However, this should
2611 be used with caution, as it can GC.
2613 This function will not function as expected on systems where open()
2614 is not interrupted by C-g. However, the worst that can happen is
2615 the fallback to simple open(). */
2617 interruptible_open (CONST char *path, int oflag, int mode)
2619 /* This function can GC */
2620 size_t len = strlen (path);
2621 char *nonreloc = (char *) alloca (len + 1);
2623 /* Must copy PATH, because it might be the data of a Lisp_String,
2624 which could be relocated by GC when checking for QUIT. */
2625 memcpy (nonreloc, path, len + 1);
2627 PATHNAME_CONVERT_OUT (nonreloc);
2631 int rtnval = open (nonreloc, oflag, mode);
2632 if (!(rtnval == -1 && errno == EINTR))
2634 /* open() was interrupted. Was QUIT responsible? */
2639 #ifdef ENCAPSULATE_CLOSE
2641 sys_close (int filedes)
2643 #ifdef INTERRUPTIBLE_CLOSE
2645 REGISTER int rtnval;
2647 while ((rtnval = close (filedes)) == -1
2648 && (errno == EINTR))
2651 /* If close is interrupted SunOS 4.1 may or may not have closed the
2652 file descriptor. If it did the second close will fail with
2653 errno = EBADF. That means we have succeeded. */
2654 if (rtnval == -1 && did_retry && errno == EBADF)
2659 return close (filedes);
2662 #endif /* ENCAPSULATE_CLOSE */
2665 sys_read_1 (int fildes, void *buf, size_t nbyte, int allow_quit)
2669 /* No harm in looping regardless of the INTERRUPTIBLE_IO setting. */
2670 while ((rtnval = read (fildes, buf, nbyte)) == -1
2671 && (errno == EINTR))
2679 #ifdef ENCAPSULATE_READ
2681 sys_read (int fildes, void *buf, size_t nbyte)
2683 return sys_read_1 (fildes, buf, nbyte, 0);
2685 #endif /* ENCAPSULATE_READ */
2688 sys_write_1 (int fildes, CONST void *buf, size_t nbyte, int allow_quit)
2690 ssize_t bytes_written = 0;
2691 CONST char *b = (CONST char *) buf;
2693 /* No harm in looping regardless of the INTERRUPTIBLE_IO setting. */
2696 ssize_t rtnval = write (fildes, b, nbyte);
2706 return bytes_written ? bytes_written : -1;
2710 bytes_written += rtnval;
2712 return bytes_written;
2715 #ifdef ENCAPSULATE_WRITE
2717 sys_write (int fildes, CONST void *buf, size_t nbyte)
2719 return sys_write_1 (fildes, buf, nbyte, 0);
2721 #endif /* ENCAPSULATE_WRITE */
2724 /**************** stdio calls ****************/
2726 /* There is at least some evidence that the stdio calls are interruptible
2727 just like the normal system calls, at least on some systems. In any
2728 case, it doesn't hurt to encapsulate them. */
2730 /* #### Should also encapsulate fflush().
2731 #### Should conceivably encapsulate getchar() etc. What a pain! */
2733 #ifdef ENCAPSULATE_FOPEN
2735 sys_fopen (CONST char *path, CONST char *type)
2737 PATHNAME_CONVERT_OUT (path);
2738 #if defined (WINDOWSNT)
2742 const char * type_save = type;
2744 /* Force all file handles to be non-inheritable. This is necessary to
2745 ensure child processes don't unwittingly inherit handles that might
2746 prevent future file access. */
2750 else if (type[0] == 'w' || type[0] == 'a')
2751 oflag = O_WRONLY | O_CREAT | O_TRUNC;
2755 /* Only do simplistic option parsing. */
2759 oflag &= ~(O_RDONLY | O_WRONLY);
2762 else if (type[0] == 'b')
2767 else if (type[0] == 't')
2774 fd = open (path, oflag | _O_NOINHERIT, 0644);
2778 return _fdopen (fd, type_save);
2780 #elif defined (INTERRUPTIBLE_OPEN)
2783 while (!(rtnval = fopen (path, type)) && (errno == EINTR))
2788 return fopen (path, type);
2791 #endif /* ENCAPSULATE_FOPEN */
2794 #ifdef ENCAPSULATE_FCLOSE
2796 sys_fclose (FILE *stream)
2798 #ifdef INTERRUPTIBLE_CLOSE
2801 while ((rtnval = fclose (stream)) == EOF
2802 && (errno == EINTR))
2806 return fclose (stream);
2809 #endif /* ENCAPSULATE_FCLOSE */
2812 #ifdef ENCAPSULATE_FREAD
2814 sys_fread (void *ptr, size_t size, size_t nitem, FILE *stream)
2816 #ifdef INTERRUPTIBLE_IO
2818 size_t items_read = 0;
2819 char *b = (char *) ptr;
2823 rtnval = fread (b, size, nitem, stream);
2826 if (ferror (stream) && errno == EINTR)
2833 items_read += rtnval;
2835 return (items_read);
2837 return fread (ptr, size, nitem, stream);
2840 #endif /* ENCAPSULATE_FREAD */
2843 #ifdef ENCAPSULATE_FWRITE
2845 sys_fwrite (CONST void *ptr, size_t size, size_t nitem, FILE *stream)
2847 #ifdef INTERRUPTIBLE_IO
2849 size_t items_written = 0;
2850 CONST char *b = (CONST char *) ptr;
2854 rtnval = fwrite (b, size, nitem, stream);
2857 if (ferror (stream) && errno == EINTR)
2860 return items_written;
2864 items_written += rtnval;
2866 return (items_written);
2868 return fwrite (ptr, size, nitem, stream);
2871 #endif /* ENCAPSULATE_FWRITE */
2874 /********************* directory calls *******************/
2876 #ifdef ENCAPSULATE_CHDIR
2878 sys_chdir (CONST char *path)
2880 PATHNAME_CONVERT_OUT (path);
2881 return chdir (path);
2883 #endif /* ENCAPSULATE_CHDIR */
2886 #ifdef ENCAPSULATE_MKDIR
2888 sys_mkdir (CONST char *path, mode_t mode)
2890 PATHNAME_CONVERT_OUT (path);
2892 return mkdir (path);
2894 return mkdir (path, mode);
2897 #endif /* ENCAPSULATE_MKDIR */
2900 #ifdef ENCAPSULATE_OPENDIR
2902 sys_opendir (CONST char *filename)
2905 PATHNAME_CONVERT_OUT (filename);
2907 while (!(rtnval = opendir (filename))
2908 && (errno == EINTR))
2912 #endif /* ENCAPSULATE_OPENDIR */
2915 #ifdef ENCAPSULATE_READDIR
2917 sys_readdir (DIR *dirp)
2921 /* Apparently setting errno is necessary on some systems?
2922 Maybe readdir() doesn't always set errno ?! */
2923 while (!(errno = 0, rtnval = readdir (dirp))
2924 && (errno == EINTR))
2929 if (rtnval == NULL) /* End of directory */
2932 Extcount external_len;
2933 int ascii_filename_p = 1;
2934 CONST Extbyte * CONST external_name = (CONST Extbyte *) rtnval->d_name;
2936 /* Optimize for the common all-ASCII case, computing len en passant */
2937 for (external_len = 0; external_name[external_len] ; external_len++)
2939 if (!BYTE_ASCII_P (external_name[external_len]))
2940 ascii_filename_p = 0;
2942 if (ascii_filename_p)
2945 { /* Non-ASCII filename */
2946 static Bufbyte_dynarr *internal_DIRENTRY;
2947 CONST Bufbyte *internal_name;
2948 Bytecount internal_len;
2949 if (!internal_DIRENTRY)
2950 internal_DIRENTRY = Dynarr_new (Bufbyte);
2952 Dynarr_reset (internal_DIRENTRY);
2954 Dynarr_add_many (internal_DIRENTRY, (Bufbyte *) rtnval,
2955 offsetof (DIRENTRY, d_name));
2958 convert_from_external_format (external_name, external_len,
2959 &internal_len, FORMAT_FILENAME);
2961 Dynarr_add_many (internal_DIRENTRY, internal_name, internal_len);
2962 Dynarr_add (internal_DIRENTRY, 0); /* zero-terminate */
2963 return (DIRENTRY *) Dynarr_atp (internal_DIRENTRY, 0);
2968 #endif /* ENCAPSULATE_READDIR */
2971 #ifdef ENCAPSULATE_CLOSEDIR
2973 sys_closedir (DIR *dirp)
2977 while ((rtnval = closedir (dirp)) == -1
2978 && (errno == EINTR))
2982 #endif /* ENCAPSULATE_CLOSEDIR */
2985 #ifdef ENCAPSULATE_RMDIR
2987 sys_rmdir (CONST char *path)
2989 PATHNAME_CONVERT_OUT (path);
2990 return rmdir (path);
2992 #endif /* ENCAPSULATE_RMDIR */
2995 /***************** file-information calls ******************/
2997 #ifdef ENCAPSULATE_ACCESS
2999 sys_access (CONST char *path, int mode)
3001 PATHNAME_CONVERT_OUT (path);
3002 return access (path, mode);
3004 #endif /* ENCAPSULATE_ACCESS */
3008 #ifdef ENCAPSULATE_EACCESS
3010 sys_eaccess (CONST char *path, int mode)
3012 PATHNAME_CONVERT_OUT (path);
3013 return eaccess (path, mode);
3015 #endif /* ENCAPSULATE_EACCESS */
3016 #endif /* HAVE_EACCESS */
3019 #ifdef ENCAPSULATE_LSTAT
3021 sys_lstat (CONST char *path, struct stat *buf)
3023 PATHNAME_CONVERT_OUT (path);
3024 return lstat (path, buf);
3026 #endif /* ENCAPSULATE_LSTAT */
3029 #ifdef ENCAPSULATE_READLINK
3031 sys_readlink (CONST char *path, char *buf, size_t bufsiz)
3033 PATHNAME_CONVERT_OUT (path);
3034 /* #### currently we don't do conversions on the incoming data */
3035 return readlink (path, buf, bufsiz);
3037 #endif /* ENCAPSULATE_READLINK */
3040 #ifdef ENCAPSULATE_STAT
3042 sys_stat (CONST char *path, struct stat *buf)
3044 PATHNAME_CONVERT_OUT (path);
3045 return stat (path, buf);
3047 #endif /* ENCAPSULATE_STAT */
3050 /****************** file-manipulation calls *****************/
3052 #ifdef ENCAPSULATE_CHMOD
3054 sys_chmod (CONST char *path, mode_t mode)
3056 PATHNAME_CONVERT_OUT (path);
3057 return chmod (path, mode);
3059 #endif /* ENCAPSULATE_CHMOD */
3062 #ifdef ENCAPSULATE_CREAT
3064 sys_creat (CONST char *path, mode_t mode)
3066 PATHNAME_CONVERT_OUT (path);
3067 return creat (path, mode);
3069 #endif /* ENCAPSULATE_CREAT */
3072 #ifdef ENCAPSULATE_LINK
3074 sys_link (CONST char *existing, CONST char *new)
3076 PATHNAME_CONVERT_OUT (existing);
3077 PATHNAME_CONVERT_OUT (new);
3078 return link (existing, new);
3080 #endif /* ENCAPSULATE_LINK */
3083 #ifdef ENCAPSULATE_RENAME
3085 sys_rename (CONST char *old, CONST char *new)
3087 PATHNAME_CONVERT_OUT (old);
3088 PATHNAME_CONVERT_OUT (new);
3090 /* Windows rename fails if NEW exists */
3091 if (rename (old, new) == 0)
3093 if (errno != EEXIST)
3096 #endif /* WINDOWSNT */
3097 return rename (old, new);
3099 #endif /* ENCAPSULATE_RENAME */
3102 #ifdef ENCAPSULATE_SYMLINK
3104 sys_symlink (CONST char *name1, CONST char *name2)
3106 PATHNAME_CONVERT_OUT (name1);
3107 PATHNAME_CONVERT_OUT (name2);
3108 return symlink (name1, name2);
3110 #endif /* ENCAPSULATE_SYMLINK */
3113 #ifdef ENCAPSULATE_UNLINK
3115 sys_unlink (CONST char *path)
3117 PATHNAME_CONVERT_OUT (path);
3118 return unlink (path);
3120 #endif /* ENCAPSULATE_UNLINK */
3123 #ifdef ENCAPSULATE_EXECVP
3125 sys_execvp (CONST char *path, char * CONST * argv)
3130 PATHNAME_CONVERT_OUT (path);
3131 for (argc = 0; argv[argc]; argc++)
3133 new_argv = alloca_array (char *, argc + 1);
3134 for (i = 0; i < argc; i++)
3136 new_argv[i] = argv[i];
3137 PATHNAME_CONVERT_OUT (new_argv[i]);
3139 new_argv[argc] = NULL;
3140 return execvp (path, new_argv);
3142 #endif /* ENCAPSULATE_EXECVP */
3145 /************************************************************************/
3146 /* Emulations of missing system calls */
3147 /************************************************************************/
3149 /***** (these are primarily required for USG, it seems) *****/
3153 getcwd (char *pathname, int size)
3155 return getwd (pathname);
3157 #endif /* emulate getcwd */
3162 * Warning, this function may not duplicate BSD 4.2 action properly
3163 * under error conditions.
3168 getwd (char *pathname)
3170 char *npath, *spath;
3171 #if !__STDC__ && !defined(STDC_HEADERS)
3172 extern char *getcwd ();
3175 spath = npath = getcwd ((char *) 0, MAXPATHLEN);
3178 /* On Altos 3068, getcwd can return @hostname/dir, so discard
3179 up to first slash. Should be harmless on other systems. */
3180 while (*npath && *npath != '/')
3182 strcpy (pathname, npath);
3183 xfree (spath); /* getcwd uses malloc */
3186 #endif /* HAVE_GETWD */
3187 #endif /* 0 - mrb */
3190 * Emulate rename using unlink/link. Note that this is
3191 * only partially correct. Also, doesn't enforce restriction
3192 * that files be of same type (regular->regular, dir->dir, etc).
3197 rename (CONST char *from, CONST char *to)
3199 if (access (from, 0) == 0)
3202 if (link (from, to) == 0)
3203 if (unlink (from) == 0)
3208 #endif /* HAVE_RENAME */
3213 /* HPUX curses library references perror, but as far as we know
3214 it won't be called. Anyway this definition will do for now. */
3220 #endif /* not HAVE_PERROR */
3226 * Emulate BSD dup2. First close newd if it already exists.
3227 * Then, attempt to dup oldd. If not successful, call dup2 recursively
3228 * until we are, then close the unsuccessful ones.
3232 dup2 (int oldd, int newd)
3239 fd = fcntl (oldd, F_DUPFD, newd);
3241 error ("can't dup2 (%i,%i) : %s", oldd, newd, strerror (errno));
3248 ret = dup2 (old, new);
3251 #endif /* F_DUPFD */
3254 #endif /* not HAVE_DUP2 */
3257 * Gettimeofday. Simulate as much as possible. Only accurate
3258 * to nearest second. Emacs doesn't use tzp so ignore it for now.
3261 #if !defined (HAVE_GETTIMEOFDAY)
3264 gettimeofday (struct timeval *tp, struct timezone *tzp)
3266 extern long time ();
3268 tp->tv_sec = time ((long *)0);
3271 tzp->tz_minuteswest = -1;
3275 #endif /* !HAVE_GETTIMEOFDAY */
3277 /* No need to encapsulate utime and utimes explicitly because all
3278 access to those functions goes through the following. */
3281 set_file_times (char *filename, EMACS_TIME atime, EMACS_TIME mtime)
3284 struct timeval tv[2];
3287 return utimes (filename, tv);
3288 #else /* not HAVE_UTIMES */
3290 utb.actime = EMACS_SECS (atime);
3291 utb.modtime = EMACS_SECS (mtime);
3292 return utime (filename, &utb);
3293 #endif /* not HAVE_UTIMES */
3298 static long ticks_per_second;
3299 static long orig_user_ticks, orig_system_ticks;
3300 EMACS_TIME orig_real_time;
3302 static int process_times_available;
3304 /* Return the relative user and system tick count. We try to
3305 maintain calculations in terms of integers as long as possible
3306 for increased accuracy. */
3309 get_process_times_1 (long *user_ticks, long *system_ticks)
3311 #if defined (_SC_CLK_TCK) || defined (CLK_TCK) && !defined(WINDOWSNT)
3312 /* We have the POSIX times() function available. */
3315 *user_ticks = (long) tttt.tms_utime;
3316 *system_ticks = (long) tttt.tms_stime;
3318 #elif defined (CLOCKS_PER_SEC)
3319 *user_ticks = (long) clock ();
3328 init_process_times_very_early (void)
3330 #if defined (_SC_CLK_TCK)
3331 ticks_per_second = sysconf (_SC_CLK_TCK);
3332 #elif defined (CLK_TCK)
3333 ticks_per_second = CLK_TCK;
3334 #elif defined (CLOCKS_PER_SEC)
3335 ticks_per_second = CLOCKS_PER_SEC;
3338 process_times_available = get_process_times_1 (&orig_user_ticks,
3339 &orig_system_ticks);
3340 EMACS_GET_TIME (orig_real_time);
3343 /* Return the user and system times used up by this process so far. */
3345 get_process_times (double *user_time, double *system_time, double *real_time)
3347 EMACS_TIME curr_real_time;
3348 EMACS_TIME elapsed_time;
3349 long curr_user_ticks, curr_system_ticks;
3351 EMACS_GET_TIME (curr_real_time);
3352 EMACS_SUB_TIME (elapsed_time, curr_real_time, orig_real_time);
3353 *real_time = (EMACS_SECS (elapsed_time)
3354 + ((double) EMACS_USECS (elapsed_time)) / 1000000);
3355 if (get_process_times_1 (&curr_user_ticks, &curr_system_ticks))
3357 *user_time = (((double) (curr_user_ticks - orig_user_ticks))
3358 / ticks_per_second);
3359 *system_time = (((double) (curr_system_ticks - orig_system_ticks))
3360 / ticks_per_second);
3365 *user_time = *real_time;
3376 /* Figure out how many bits the system's random number generator uses.
3377 `random' and `lrand48' are assumed to return 31 usable bits.
3378 BSD `rand' returns a 31 bit value but the low order bits are unusable;
3379 so we'll shift it and treat it like the 15-bit USG `rand'. */
3383 # define RAND_BITS 31
3384 # else /* !HAVE_RANDOM */
3385 # ifdef HAVE_LRAND48
3386 # define RAND_BITS 31
3387 # define random lrand48
3388 # else /* !HAVE_LRAND48 */
3389 # define RAND_BITS 15
3390 # if RAND_MAX == 32767
3391 # define random rand
3392 # else /* RAND_MAX != 32767 */
3393 # if RAND_MAX == 2147483647
3394 # define random() (rand () >> 16)
3395 # else /* RAND_MAX != 2147483647 */
3397 # define random rand
3399 # define random() (rand () >> 16)
3401 # endif /* RAND_MAX != 2147483647 */
3402 # endif /* RAND_MAX != 32767 */
3403 # endif /* !HAVE_LRAND48 */
3404 # endif /* !HAVE_RANDOM */
3405 #endif /* !RAND_BITS */
3407 void seed_random (long arg);
3409 seed_random (long arg)
3412 srandom ((unsigned int)arg);
3414 # ifdef HAVE_LRAND48
3417 srand ((unsigned int)arg);
3423 * Build a full Emacs-sized word out of whatever we've got.
3424 * This suffices even for a 64-bit architecture with a 15-bit rand.
3426 long get_random (void);
3430 long val = random ();
3431 #if VALBITS > RAND_BITS
3432 val = (val << RAND_BITS) ^ random ();
3433 #if VALBITS > 2*RAND_BITS
3434 val = (val << RAND_BITS) ^ random ();
3435 #if VALBITS > 3*RAND_BITS
3436 val = (val << RAND_BITS) ^ random ();
3437 #if VALBITS > 4*RAND_BITS
3438 val = (val << RAND_BITS) ^ random ();
3439 #endif /* need at least 5 */
3440 #endif /* need at least 4 */
3441 #endif /* need at least 3 */
3442 #endif /* need at least 2 */
3443 return val & ((1L << VALBITS) - 1);
3447 /************************************************************************/
3448 /* Strings corresponding to defined signals */
3449 /************************************************************************/
3451 #if !defined (SYS_SIGLIST_DECLARED) && !defined (HAVE_SYS_SIGLIST)
3453 #if defined(WINDOWSNT) || defined(__CYGWIN32__)
3454 CONST char *sys_siglist[] =
3460 "illegal instruction",
3464 "floating point exception",
3467 "segmentation violation",
3468 "bad argument to system call",
3469 "write on a pipe with no one to read it",
3471 "software termination signal from kill",
3473 "sendable stop signal not from tty",
3474 "stop signal from tty",
3475 "continue a stopped process",
3476 "child status has changed",
3477 "background read attempted from control tty",
3478 "background write attempted from control tty",
3479 "input record available at control tty",
3480 "exceeded CPU time limit",
3481 "exceeded file size limit"
3487 CONST char *sys_siglist[NSIG + 1] =
3489 /* AIX has changed the signals a bit */
3490 DEFER_GETTEXT ("bogus signal"), /* 0 */
3491 DEFER_GETTEXT ("hangup"), /* 1 SIGHUP */
3492 DEFER_GETTEXT ("interrupt"), /* 2 SIGINT */
3493 DEFER_GETTEXT ("quit"), /* 3 SIGQUIT */
3494 DEFER_GETTEXT ("illegal instruction"), /* 4 SIGILL */
3495 DEFER_GETTEXT ("trace trap"), /* 5 SIGTRAP */
3496 DEFER_GETTEXT ("IOT instruction"), /* 6 SIGIOT */
3497 DEFER_GETTEXT ("crash likely"), /* 7 SIGDANGER */
3498 DEFER_GETTEXT ("floating point exception"), /* 8 SIGFPE */
3499 DEFER_GETTEXT ("kill"), /* 9 SIGKILL */
3500 DEFER_GETTEXT ("bus error"), /* 10 SIGBUS */
3501 DEFER_GETTEXT ("segmentation violation"), /* 11 SIGSEGV */
3502 DEFER_GETTEXT ("bad argument to system call"), /* 12 SIGSYS */
3503 DEFER_GETTEXT ("write on a pipe with no one to read it"), /* 13 SIGPIPE */
3504 DEFER_GETTEXT ("alarm clock"), /* 14 SIGALRM */
3505 DEFER_GETTEXT ("software termination signum"), /* 15 SIGTERM */
3506 DEFER_GETTEXT ("user defined signal 1"), /* 16 SIGUSR1 */
3507 DEFER_GETTEXT ("user defined signal 2"), /* 17 SIGUSR2 */
3508 DEFER_GETTEXT ("death of a child"), /* 18 SIGCLD */
3509 DEFER_GETTEXT ("power-fail restart"), /* 19 SIGPWR */
3510 DEFER_GETTEXT ("bogus signal"), /* 20 */
3511 DEFER_GETTEXT ("bogus signal"), /* 21 */
3512 DEFER_GETTEXT ("bogus signal"), /* 22 */
3513 DEFER_GETTEXT ("bogus signal"), /* 23 */
3514 DEFER_GETTEXT ("bogus signal"), /* 24 */
3515 DEFER_GETTEXT ("LAN I/O interrupt"), /* 25 SIGAIO */
3516 DEFER_GETTEXT ("PTY I/O interrupt"), /* 26 SIGPTY */
3517 DEFER_GETTEXT ("I/O intervention required"), /* 27 SIGIOINT */
3519 DEFER_GETTEXT ("HFT grant"), /* 28 SIGGRANT */
3520 DEFER_GETTEXT ("HFT retract"), /* 29 SIGRETRACT */
3521 DEFER_GETTEXT ("HFT sound done"), /* 30 SIGSOUND */
3522 DEFER_GETTEXT ("HFT input ready"), /* 31 SIGMSG */
3526 #else /* USG, not AIX */
3527 CONST char *sys_siglist[NSIG + 1] =
3529 DEFER_GETTEXT ("bogus signal"), /* 0 */
3530 DEFER_GETTEXT ("hangup"), /* 1 SIGHUP */
3531 DEFER_GETTEXT ("interrupt"), /* 2 SIGINT */
3532 DEFER_GETTEXT ("quit"), /* 3 SIGQUIT */
3533 DEFER_GETTEXT ("illegal instruction"), /* 4 SIGILL */
3534 DEFER_GETTEXT ("trace trap"), /* 5 SIGTRAP */
3535 DEFER_GETTEXT ("IOT instruction"), /* 6 SIGIOT */
3536 DEFER_GETTEXT ("EMT instruction"), /* 7 SIGEMT */
3537 DEFER_GETTEXT ("floating point exception"), /* 8 SIGFPE */
3538 DEFER_GETTEXT ("kill"), /* 9 SIGKILL */
3539 DEFER_GETTEXT ("bus error"), /* 10 SIGBUS */
3540 DEFER_GETTEXT ("segmentation violation"), /* 11 SIGSEGV */
3541 DEFER_GETTEXT ("bad argument to system call"), /* 12 SIGSYS */
3542 DEFER_GETTEXT ("write on a pipe with no one to read it"), /* 13 SIGPIPE */
3543 DEFER_GETTEXT ("alarm clock"), /* 14 SIGALRM */
3544 DEFER_GETTEXT ("software termination signum"), /* 15 SIGTERM */
3545 DEFER_GETTEXT ("user defined signal 1"), /* 16 SIGUSR1 */
3546 DEFER_GETTEXT ("user defined signal 2"), /* 17 SIGUSR2 */
3547 DEFER_GETTEXT ("death of a child"), /* 18 SIGCLD */
3548 DEFER_GETTEXT ("power-fail restart"), /* 19 SIGPWR */
3550 DEFER_GETTEXT ("window size changed"), /* 20 SIGWINCH */
3551 DEFER_GETTEXT ("urgent socket condition"), /* 21 SIGURG */
3552 DEFER_GETTEXT ("pollable event occurred"), /* 22 SIGPOLL */
3553 DEFER_GETTEXT ("stop (cannot be caught or ignored)"), /* 23 SIGSTOP */
3554 DEFER_GETTEXT ("user stop requested from tty"), /* 24 SIGTSTP */
3555 DEFER_GETTEXT ("stopped process has been continued"), /* 25 SIGCONT */
3556 DEFER_GETTEXT ("background tty read attempted"), /* 26 SIGTTIN */
3557 DEFER_GETTEXT ("background tty write attempted"), /* 27 SIGTTOU */
3558 DEFER_GETTEXT ("virtual timer expired"), /* 28 SIGVTALRM */
3559 DEFER_GETTEXT ("profiling timer expired"), /* 29 SIGPROF */
3560 DEFER_GETTEXT ("exceeded cpu limit"), /* 30 SIGXCPU */
3561 DEFER_GETTEXT ("exceeded file size limit"), /* 31 SIGXFSZ */
3562 DEFER_GETTEXT ("process's lwps are blocked"), /* 32 SIGWAITING */
3563 DEFER_GETTEXT ("special signal used by thread library"), /* 33 SIGLWP */
3565 DEFER_GETTEXT ("special signal used by CPR"), /* 34 SIGFREEZE */
3568 DEFER_GETTEXT ("special signal used by CPR"), /* 35 SIGTHAW */
3573 #endif /* not AIX */
3576 CONST char *sys_siglist[NSIG + 1] =
3578 DEFER_GETTEXT ("null signal"), /* 0 SIGNULL */
3579 DEFER_GETTEXT ("hangup"), /* 1 SIGHUP */
3580 DEFER_GETTEXT ("interrupt"), /* 2 SIGINT */
3581 DEFER_GETTEXT ("quit"), /* 3 SIGQUIT */
3582 DEFER_GETTEXT ("illegal instruction"), /* 4 SIGILL */
3583 DEFER_GETTEXT ("trace trap"), /* 5 SIGTRAP */
3584 DEFER_GETTEXT ("abort termination"), /* 6 SIGABRT */
3585 DEFER_GETTEXT ("SIGEMT"), /* 7 SIGEMT */
3586 DEFER_GETTEXT ("floating point exception"), /* 8 SIGFPE */
3587 DEFER_GETTEXT ("kill"), /* 9 SIGKILL */
3588 DEFER_GETTEXT ("bus error"), /* 10 SIGBUS */
3589 DEFER_GETTEXT ("segmentation violation"), /* 11 SIGSEGV */
3590 DEFER_GETTEXT ("bad argument to system call"), /* 12 SIGSYS */
3591 DEFER_GETTEXT ("write on a pipe with no reader"), /* 13 SIGPIPE */
3592 DEFER_GETTEXT ("alarm clock"), /* 14 SIGALRM */
3593 DEFER_GETTEXT ("software termination signal"), /* 15 SIGTERM */
3594 DEFER_GETTEXT ("user defined signal 1"), /* 16 SIGUSR1 */
3595 DEFER_GETTEXT ("user defined signal 2"), /* 17 SIGUSR2 */
3596 DEFER_GETTEXT ("child stopped or terminated"), /* 18 SIGCLD */
3597 DEFER_GETTEXT ("power-fail restart"), /* 19 SIGPWR */
3598 DEFER_GETTEXT ("window size changed"), /* 20 SIGWINCH */
3599 DEFER_GETTEXT ("undefined"), /* 21 */
3600 DEFER_GETTEXT ("pollable event occurred"), /* 22 SIGPOLL */
3601 DEFER_GETTEXT ("sendable stop signal not from tty"), /* 23 SIGSTOP */
3602 DEFER_GETTEXT ("stop signal from tty"), /* 24 SIGSTP */
3603 DEFER_GETTEXT ("continue a stopped process"), /* 25 SIGCONT */
3604 DEFER_GETTEXT ("attempted background tty read"), /* 26 SIGTTIN */
3605 DEFER_GETTEXT ("attempted background tty write"), /* 27 SIGTTOU */
3606 DEFER_GETTEXT ("undefined"), /* 28 */
3607 DEFER_GETTEXT ("undefined"), /* 29 */
3608 DEFER_GETTEXT ("undefined"), /* 30 */
3609 DEFER_GETTEXT ("undefined"), /* 31 */
3610 DEFER_GETTEXT ("undefined"), /* 32 */
3611 DEFER_GETTEXT ("socket (TCP/IP) urgent data arrival"), /* 33 SIGURG */
3612 DEFER_GETTEXT ("I/O is possible"), /* 34 SIGIO */
3613 DEFER_GETTEXT ("exceeded cpu time limit"), /* 35 SIGXCPU */
3614 DEFER_GETTEXT ("exceeded file size limit"), /* 36 SIGXFSZ */
3615 DEFER_GETTEXT ("virtual time alarm"), /* 37 SIGVTALRM */
3616 DEFER_GETTEXT ("profiling time alarm"), /* 38 SIGPROF */
3617 DEFER_GETTEXT ("undefined"), /* 39 */
3618 DEFER_GETTEXT ("file record locks revoked"), /* 40 SIGLOST */
3619 DEFER_GETTEXT ("undefined"), /* 41 */
3620 DEFER_GETTEXT ("undefined"), /* 42 */
3621 DEFER_GETTEXT ("undefined"), /* 43 */
3622 DEFER_GETTEXT ("undefined"), /* 44 */
3623 DEFER_GETTEXT ("undefined"), /* 45 */
3624 DEFER_GETTEXT ("undefined"), /* 46 */
3625 DEFER_GETTEXT ("undefined"), /* 47 */
3626 DEFER_GETTEXT ("undefined"), /* 48 */
3627 DEFER_GETTEXT ("undefined"), /* 49 */
3628 DEFER_GETTEXT ("undefined"), /* 50 */
3629 DEFER_GETTEXT ("undefined"), /* 51 */
3630 DEFER_GETTEXT ("undefined"), /* 52 */
3631 DEFER_GETTEXT ("undefined"), /* 53 */
3632 DEFER_GETTEXT ("undefined"), /* 54 */
3633 DEFER_GETTEXT ("undefined"), /* 55 */
3634 DEFER_GETTEXT ("undefined"), /* 56 */
3635 DEFER_GETTEXT ("undefined"), /* 57 */
3636 DEFER_GETTEXT ("undefined"), /* 58 */
3637 DEFER_GETTEXT ("undefined"), /* 59 */
3638 DEFER_GETTEXT ("undefined"), /* 60 */
3639 DEFER_GETTEXT ("undefined"), /* 61 */
3640 DEFER_GETTEXT ("undefined"), /* 62 */
3641 DEFER_GETTEXT ("undefined"), /* 63 */
3642 DEFER_GETTEXT ("notification message in mess. queue"), /* 64 SIGDGNOTIFY */
3647 #endif /* ! SYS_SIGLIST_DECLARED && ! HAVE_SYS_SIGLIST */
3650 /************************************************************************/
3651 /* Directory routines for systems that don't have them */
3652 /************************************************************************/
3654 #ifdef SYSV_SYSTEM_DIR
3658 #if defined(BROKEN_CLOSEDIR) || !defined(HAVE_CLOSEDIR)
3660 closedir (DIR *dirp) /* stream from opendir */
3664 rtnval = sys_close (dirp->dd_fd);
3666 /* Some systems (like Solaris) allocate the buffer and the DIR all
3667 in one block. Why in the world are we freeing this ourselves
3669 #if ! (defined (sun) && defined (USG5_4))
3670 xfree ((char *) dirp->dd_buf); /* directory block defined in <dirent.h> */
3672 xfree ((char *) dirp);
3675 #endif /* BROKEN_CLOSEDIR or not HAVE_CLOSEDIR */
3676 #endif /* SYSV_SYSTEM_DIR */
3678 #ifdef NONSYSTEM_DIR_LIBRARY
3681 opendir (CONST char *filename) /* name of directory */
3683 DIR *dirp; /* -> malloc'ed storage */
3684 int fd; /* file descriptor for read */
3685 struct stat sbuf; /* result of fstat */
3687 fd = sys_open (filename, O_RDONLY);
3691 if (fstat (fd, &sbuf) < 0
3692 || (sbuf.st_mode & S_IFMT) != S_IFDIR
3693 || (dirp = (DIR *) malloc (sizeof (DIR))) == 0)
3696 return 0; /* bad luck today */
3700 dirp->dd_loc = dirp->dd_size = 0; /* refill needed */
3706 closedir (DIR *dirp) /* stream from opendir */
3708 sys_close (dirp->dd_fd);
3716 ino_t od_ino; /* inode */
3717 char od_name[DIRSIZ]; /* filename */
3720 static struct direct dir_static; /* simulated directory contents */
3724 readdir (DIR *dirp) /* stream from opendir */
3726 struct olddir *dp; /* -> directory data */
3730 if (dirp->dd_loc >= dirp->dd_size)
3731 dirp->dd_loc = dirp->dd_size = 0;
3733 if (dirp->dd_size == 0 /* refill buffer */
3734 && (dirp->dd_size = sys_read (dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ)) <= 0)
3737 dp = (struct olddir *) &dirp->dd_buf[dirp->dd_loc];
3738 dirp->dd_loc += sizeof (struct olddir);
3740 if (dp->od_ino != 0) /* not deleted entry */
3742 dir_static.d_ino = dp->od_ino;
3743 strncpy (dir_static.d_name, dp->od_name, DIRSIZ);
3744 dir_static.d_name[DIRSIZ] = '\0';
3745 dir_static.d_namlen = strlen (dir_static.d_name);
3746 dir_static.d_reclen = sizeof (struct direct)
3748 + dir_static.d_namlen - dir_static.d_namlen % 4;
3749 return &dir_static; /* -> simulated structure */
3755 #endif /* NONSYSTEM_DIR_LIBRARY */
3758 /* mkdir and rmdir functions, for systems which don't have them. */
3762 * Written by Robert Rother, Mariah Corporation, August 1985.
3764 * If you want it, it's yours. All I ask in return is that if you
3765 * figure out how to do this in a Bourne Shell script you send me
3767 * sdcsvax!rmr or rmr@uscd
3769 * Severely hacked over by John Gilmore to make a 4.2BSD compatible
3770 * subroutine. 11Mar86; hoptoad!gnu
3772 * Modified by rmtodd@uokmax 6-28-87 -- when making an already existing dir,
3773 * subroutine didn't return EEXIST. It does now.
3779 #ifdef MKDIR_PROTOTYPE
3783 mkdir (CONST char *dpath, int dmode)
3786 int cpid, status, fd;
3787 struct stat statbuf;
3789 if (stat (dpath, &statbuf) == 0)
3791 errno = EEXIST; /* Stat worked, so it already exists */
3795 /* If stat fails for a reason other than non-existence, return error */
3796 if (errno != ENOENT)
3799 synch_process_alive = 1;
3800 switch (cpid = fork ())
3803 case -1: /* Error in fork() */
3804 return -1; /* Errno is set already */
3806 case 0: /* Child process */
3809 * Cheap hack to set mode of new directory. Since this
3810 * child process is going away anyway, we zap its umask.
3811 * ####, this won't suffice to set SUID, SGID, etc. on this
3812 * directory. Does anybody care?
3814 status = umask (0); /* Get current umask */
3815 status = umask (status | (0777 & ~dmode)); /* Set for mkdir */
3816 fd = sys_open ("/dev/null", O_RDWR);
3819 if (fd != STDIN_FILENO) dup2 (fd, STDIN_FILENO);
3820 if (fd != STDOUT_FILENO) dup2 (fd, STDOUT_FILENO);
3821 if (fd != STDERR_FILENO) dup2 (fd, STDERR_FILENO);
3823 execl ("/bin/mkdir", "mkdir", dpath, (char *) 0);
3824 _exit (-1); /* Can't exec /bin/mkdir */
3827 default: /* Parent process */
3828 wait_for_termination (cpid);
3831 if (synch_process_death != 0 || synch_process_retcode != 0)
3833 errno = EIO; /* We don't know why, but */
3834 return -1; /* /bin/mkdir failed */
3839 #endif /* not HAVE_MKDIR */
3843 rmdir (CONST char *dpath)
3845 int cpid, status, fd;
3846 struct stat statbuf;
3848 if (stat (dpath, &statbuf) != 0)
3850 /* Stat just set errno. We don't have to */
3854 synch_process_alive = 1;
3855 switch (cpid = fork ())
3858 case -1: /* Error in fork() */
3859 return (-1); /* Errno is set already */
3861 case 0: /* Child process */
3862 fd = sys_open("/dev/null", O_RDWR);
3865 if (fd != STDIN_FILENO) dup2 (fd, STDIN_FILENO);
3866 if (fd != STDOUT_FILENO) dup2 (fd, STDOUT_FILENO);
3867 if (fd != STDERR_FILENO) dup2 (fd, STDERR_FILENO);
3869 execl ("/bin/rmdir", "rmdir", dpath, (char *) 0);
3870 _exit (-1); /* Can't exec /bin/mkdir */
3872 default: /* Parent process */
3873 wait_for_termination (cpid);
3876 if (synch_process_death != 0 ||
3877 synch_process_retcode != 0)
3879 errno = EIO; /* We don't know why, but */
3880 return -1; /* /bin/rmdir failed */
3885 #endif /* !HAVE_RMDIR */
3888 /************************************************************************/
3889 /* Misc. SunOS crap */
3890 /************************************************************************/
3894 /* These are included on Sunos 4.1 when we do not use shared libraries.
3895 X11 libraries may refer to these functions but (we hope) do not
3896 actually call them. */
3916 #endif /* USE_DL_STUBS */
3920 #ifndef HAVE_STRCASECMP
3924 static unsigned char charmap[] = {
3925 '\000', '\001', '\002', '\003', '\004', '\005', '\006', '\007',
3926 '\010', '\011', '\012', '\013', '\014', '\015', '\016', '\017',
3927 '\020', '\021', '\022', '\023', '\024', '\025', '\026', '\027',
3928 '\030', '\031', '\032', '\033', '\034', '\035', '\036', '\037',
3929 '\040', '\041', '\042', '\043', '\044', '\045', '\046', '\047',
3930 '\050', '\051', '\052', '\053', '\054', '\055', '\056', '\057',
3931 '\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067',
3932 '\070', '\071', '\072', '\073', '\074', '\075', '\076', '\077',
3933 '\100', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
3934 '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
3935 '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
3936 '\170', '\171', '\172', '\133', '\134', '\135', '\136', '\137',
3937 '\140', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
3938 '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
3939 '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
3940 '\170', '\171', '\172', '\173', '\174', '\175', '\176', '\177',
3941 '\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207',
3942 '\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217',
3943 '\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227',
3944 '\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237',
3945 '\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247',
3946 '\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257',
3947 '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267',
3948 '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277',
3949 '\300', '\301', '\302', '\303', '\304', '\305', '\306', '\307',
3950 '\310', '\311', '\312', '\313', '\314', '\315', '\316', '\317',
3951 '\320', '\321', '\322', '\323', '\324', '\325', '\326', '\327',
3952 '\330', '\331', '\332', '\333', '\334', '\335', '\336', '\337',
3953 '\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347',
3954 '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357',
3955 '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367',
3956 '\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377',
3960 strcasecmp (char *s1, char *s2)
3962 unsigned char *cm = charmap;
3963 unsigned char *us1 = (unsigned char *) s1;
3964 unsigned char *us2 = (unsigned char *)s2;
3966 while (cm[*us1] == cm[*us2++])
3970 return (cm[*us1] - cm[*--us2]);
3972 #endif /* !HAVE_STRCASECMP */