git.chise.org Git - chise/xemacs-chise.git.1/blob - src/sysdep.c

   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.
   4
   5 This file is part of XEmacs.
   6
   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
  10 later version.
  11
  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
  15 for more details.
  16
  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.  */
  21
  22 /* Synched up with: FSF 19.30 except for some Windows-NT crap. */
  23
  24 /* Substantially cleaned up by Ben Wing, Dec. 1994 / Jan. 1995. */
  25
  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.
  28  */
  29
  30 #define DONT_ENCAPSULATE
  31
  32 #include <config.h>
  33
  34 #ifdef WINDOWSNT
  35 #include <direct.h>
  36 #ifdef __MINGW32__
  37 #include <mingw32/process.h>
  38 #else
  39 /* <process.h> should not conflict with "process.h", as per ANSI definition.
  40    This is not true with visual c though. The trick below works with
  41    VC4.2b, 5.0 and 6.0. It assumes that VC is installed in a kind of
  42    standard way, so include path ends with /include.
  43
  44    Unfortunately, this must go before lisp.h, since process.h defines abort()
  45    which will conflict with the macro defined in lisp.h
  46 */
  47 #include <../include/process.h>
  48 #endif /* __MINGW32__ */
  49 #endif /* WINDOWSNT */
  50
  51 #include "lisp.h"
  52
  53 #include <stdlib.h>
  54
  55 /* ------------------------------- */
  56 /*          basic includes         */
  57 /* ------------------------------- */
  58
  59 #ifdef HAVE_TTY
  60 #include "console-tty.h"
  61 #else
  62 #include "syssignal.h"
  63 #include "systty.h"
  64 #endif /* HAVE_TTY */
  65
  66 #include "console-stream.h"
  67
  68 #include "buffer.h"
  69 #include "events.h"
  70 #include "frame.h"
  71 #include "redisplay.h"
  72 #include "process.h"
  73 #include "sysdep.h"
  74 #include "window.h"
  75
  76 #include <setjmp.h>
  77 #ifdef HAVE_LIBGEN_H            /* Must come before sysfile.h */
  78 #include <libgen.h>
  79 #endif
  80 #include "sysfile.h"
  81 #include "syswait.h"
  82 #include "sysdir.h"
  83 #include "systime.h"
  84 #if defined(WINDOWSNT) || defined(__CYGWIN32__)
  85 #include "syssignal.h"
  86 #endif
  87 #ifndef WINDOWSNT
  88 #include <sys/times.h>
  89 #endif
  90
  91 #ifdef WINDOWSNT
  92 #include <sys/utime.h>
  93 #include "ntheap.h"
  94 #endif
  95
  96 /* ------------------------------- */
  97 /*         TTY definitions         */
  98 /* ------------------------------- */
  99
 100 #ifdef USG
 101 #include <sys/utsname.h>
 102 #if defined (TIOCGWINSZ) || defined (ISC4_0)
 103 #ifdef NEED_SIOCTL
 104 #include <sys/sioctl.h>
 105 #endif
 106 #ifdef NEED_PTEM_H
 107 #include <sys/stream.h>
 108 #include <sys/ptem.h>
 109 #endif
 110 #endif /* TIOCGWINSZ or ISC4_0 */
 111 #endif /* USG */
 112
 113 #ifdef HAVE_SYS_STROPTS_H
 114 #include <sys/stropts.h>
 115 #endif /* HAVE_SYS_STROPTS_H */
 116
 117 /* LPASS8 is new in 4.3, and makes cbreak mode provide all 8 bits.  */
 118 #ifndef LPASS8
 119 #define LPASS8 0
 120 #endif
 121
 122 #ifndef HAVE_H_ERRNO
 123 int h_errno;
 124 #endif
 125
 126 #ifdef HAVE_TTY
 127
 128 static int baud_convert[] =
 129 #ifdef BAUD_CONVERT
 130   BAUD_CONVERT;
 131 #else
 132   {
 133     0, 50, 75, 110, 135, 150, 200, 300, 600, 1200,
 134     1800, 2400, 4800, 9600, 19200, 38400
 135   };
 136 #endif
 137
 138 #endif
 139
 140 #ifdef AIXHFT
 141 static void hft_init (struct console *c);
 142 static void hft_reset (struct console *c);
 143 #include <sys/termio.h>
 144 #endif
 145
 146 /* ------------------------------- */
 147 /*          miscellaneous          */
 148 /* ------------------------------- */
 149
 150 #ifndef HAVE_UTIMES
 151 #ifndef HAVE_STRUCT_UTIMBUF
 152 /* We want to use utime rather than utimes, but we couldn't find the
 153    structure declaration.  We'll use the traditional one.  */
 154 struct utimbuf
 155 {
 156   long actime;
 157   long modtime;
 158 };
 159 #endif
 160 #endif
 161
 162 \f
 163 /************************************************************************/
 164 /*                         subprocess control                           */
 165 /************************************************************************/
 166
 167 #ifdef HAVE_TTY
 168
 169 #ifdef SIGTSTP
 170
 171 /* Arrange for character C to be read as the next input from
 172    the terminal.  */
 173 void
 174 stuff_char (struct console *con, int c)
 175 {
 176   int input_fd;
 177
 178   assert (CONSOLE_TTY_P (con));
 179   input_fd = CONSOLE_TTY_DATA (con)->infd;
 180 /* Should perhaps error if in batch mode */
 181 #ifdef TIOCSTI
 182   ioctl (input_fd, TIOCSTI, &c);
 183 #else /* no TIOCSTI */
 184   error ("Cannot stuff terminal input characters in this version of Unix.");
 185 #endif /* no TIOCSTI */
 186 }
 187
 188 #endif /* SIGTSTP */
 189
 190 #endif /* HAVE_TTY */
 191
 192 void
 193 set_exclusive_use (int fd)
 194 {
 195 #ifdef FIOCLEX
 196   ioctl (fd, FIOCLEX, 0);
 197 #endif
 198   /* Ok to do nothing if this feature does not exist */
 199 }
 200
 201 void
 202 set_descriptor_non_blocking (int fd)
 203 {
 204 /* Stride people say it's a mystery why this is needed
 205    as well as the O_NDELAY, but that it fails without this.  */
 206   /* For AIX: Apparently need this for non-blocking reads on sockets.
 207      It seems that O_NONBLOCK applies only to FIFOs?  From
 208      lowry@watson.ibm.com (Andy Lowry). */
 209   /* #### Should this be conditionalized on FIONBIO? */
 210 #if defined (STRIDE) || (defined (pfa) && defined (HAVE_PTYS)) || defined (AIX)
 211   {
 212     int one = 1;
 213     ioctl (fd, FIONBIO, &one);
 214   }
 215 #endif
 216
 217 #ifdef F_SETFL
 218   fcntl (fd, F_SETFL, O_NONBLOCK);
 219 #endif
 220 }
 221
 222 #if defined (NO_SUBPROCESSES)
 223
 224 #ifdef BSD
 225 void
 226 wait_without_blocking (void)
 227 {
 228   wait3 (0, WNOHANG | WUNTRACED, 0);
 229   synch_process_alive = 0;
 230 }
 231 #endif /* BSD */
 232
 233 #endif /* NO_SUBPROCESSES */
 234
 235
 236 #ifdef WINDOWSNT
 237 void wait_for_termination (HANDLE pHandle)
 238 #else
 239 void wait_for_termination (int pid)
 240 #endif
 241 {
 242   /* #### With the new improved SIGCHLD handling stuff, there is much
 243      less danger of race conditions and some of the comments below
 244      don't apply.  This should be updated. */
 245
 246 #if defined (NO_SUBPROCESSES)
 247   while (1)
 248     {
 249       /* No need to be tricky like below; we can just call wait(). */
 250       /* #### should figure out how to write a wait_allowing_quit().
 251          Since hardly any systems don't have subprocess support,
 252          however, there doesn't seem to be much point. */
 253       if (wait (0) == pid)
 254         return;
 255     }
 256 #elif defined (HAVE_WAITPID)
 257   /* Note that, whenever any subprocess terminates (asynch. or synch.),
 258      the SIGCHLD handler will be called and it will call wait().  Thus
 259      we cannot just call wait() ourselves, and we can't block SIGCHLD
 260      and then call wait(), because then if an asynch.  process dies
 261      while we're waiting for our synch. process, Emacs will never
 262      notice that the asynch. process died.
 263
 264      So, the general approach we take is to repeatedly block until a
 265      signal arrives, and then check if our process died using kill
 266      (pid, 0).  (We could also check the value of `synch_process_alive',
 267      since the SIGCHLD handler will reset that and we know that we're
 268      only being called on synchronous processes, but this approach is
 269      safer.  I don't trust the proper delivery of SIGCHLD.
 270
 271      Note also that we cannot use any form of waitpid().  A loop with
 272      WNOHANG will chew up CPU time; better to use sleep().  A loop
 273      without WNOWAIT will screw up the SIGCHLD handler (actually this
 274      is not true, if you duplicate the exit-status-reaping code; see
 275      below).  A loop with WNOWAIT will result in a race condition if
 276      the process terminates between the process-status check and the
 277      call to waitpid(). */
 278
 279   /* Formerly, immediate_quit was set around this function call, but
 280      that could lead to problems if the QUIT happened when SIGCHLD was
 281      blocked -- it would remain blocked.  Yet another reason why
 282      immediate_quit is a bad idea.  In any case, there is no reason to
 283      resort to this because either the SIGIO or the SIGALRM will stop
 284      the block in EMACS_WAIT_FOR_SIGNAL(). */
 285
 286   /* Apparently there are bugs on some systems with the second method
 287      used below (the EMACS_BLOCK_SIGNAL method), whereby zombie
 288      processes get left around.  It appears in those cases that the
 289      SIGCHLD handler is never getting invoked.  It's not clear whether
 290      this is an Emacs bug or a kernel bug or both: on HPUX this
 291      problem is observed only with XEmacs, but under Solaris 2.4 all
 292      sorts of different programs have problems with zombies.  The
 293      method we use here does not require a working SIGCHLD (but will
 294      not break if it is working), and should be safe. */
 295   /*
 296      We use waitpid(), contrary to the remarks above.  There is no
 297      race condition, because the three situations when sigchld_handler
 298      is invoked should be handled OK:
 299
 300      - handler invoked before waitpid(): In this case, subprocess
 301        status will be set by sigchld_handler.  waitpid() here will
 302        return -1 with errno set to ECHILD, which is a valid exit
 303        condition.
 304
 305      - handler invoked during waitpid(): as above, except that errno
 306        here will be set to EINTR.  This will cause waitpid() to be
 307        called again, and this time it will exit with ECHILD.
 308
 309      - handler invoked after waitpid(): The following code will reap
 310        the subprocess. In the handler, wait() will return -1 because
 311        there is no child to reap, and the handler will exit without
 312        modifying child subprocess status.  */
 313   int ret, status;
 314
 315   /* Because the SIGCHLD handler can potentially reap the synchronous
 316      subprocess, we should take care of that.  */
 317
 318   /* Will stay in the do loop as long as:
 319      1. Process is alive
 320      2. Ctrl-G is not pressed */
 321   do
 322     {
 323       QUIT;
 324       ret = waitpid (pid, &status, 0);
 325       /* waitpid returns 0 if the process is still alive. */
 326     }
 327   while (ret == 0 || (ret == -1 && errno == EINTR));
 328
 329   if (ret == pid) /* Success */
 330     /* Set synch process globals.  This is can also happen
 331        in sigchld_handler, and that code is duplicated. */
 332     {
 333       synch_process_alive = 0;
 334       if (WIFEXITED (status))
 335         synch_process_retcode = WEXITSTATUS (status);
 336       else if (WIFSIGNALED (status))
 337         synch_process_death = signal_name (WTERMSIG (status));
 338     }
 339   /* On exiting the loop, ret will be -1, with errno set to ECHILD if
 340      the child has already been reaped, e.g. in the signal handler.  */
 341
 342   /* Otherwise, we've had some error condition here.
 343      Per POSIX, the only other possibilities are:
 344      - EFAULT (bus error accessing arg 2) or
 345      - EINVAL (incorrect arguments),
 346      which are both program bugs.
 347
 348      Since implementations may add their own error indicators on top,
 349      we ignore it by default.  */
 350 #elif defined (WINDOWSNT)
 351   int ret = 0, status = 0;
 352   if (pHandle == NULL)
 353     {
 354       warn_when_safe (Qprocess, Qwarning, "Cannot wait for unknown process to terminate");
 355       return;
 356     }
 357   do
 358     {
 359       QUIT;
 360       ret = WaitForSingleObject(pHandle, 100);
 361     }
 362   while (ret == WAIT_TIMEOUT);
 363   if (ret == WAIT_FAILED)
 364     {
 365       warn_when_safe (Qprocess, Qwarning, "waiting for process failed");
 366     }
 367   if (ret == WAIT_ABANDONED)
 368     {
 369       warn_when_safe (Qprocess, Qwarning,
 370                       "process to wait for has been abandoned");
 371     }
 372   if (ret == WAIT_OBJECT_0)
 373     {
 374       ret = GetExitCodeProcess(pHandle, &status);
 375       if (ret)
 376         {
 377           synch_process_alive = 0;
 378           synch_process_retcode = status;
 379         }
 380       else
 381         {
 382           /* GetExitCodeProcess() didn't return a valid exit status,
 383              nothing to do.  APA */
 384           warn_when_safe (Qprocess, Qwarning,
 385                           "failure to obtain process exit value");
 386         }
 387     }
 388   if (pHandle != NULL && !CloseHandle(pHandle))
 389     {
 390       warn_when_safe (Qprocess, Qwarning,
 391                       "failure to close unknown process");
 392     }
 393 #elif defined (EMACS_BLOCK_SIGNAL) && !defined (BROKEN_WAIT_FOR_SIGNAL) && defined (SIGCHLD)
 394   while (1)
 395     {
 396       static int wait_debugging = 0; /* Set nonzero to make following
 397                            function work under dbx (at least for bsd).  */
 398       QUIT;
 399       if (wait_debugging)
 400         return;
 401
 402       EMACS_BLOCK_SIGNAL (SIGCHLD);
 403       /* Block SIGCHLD from happening during this check,
 404          to avoid race conditions. */
 405       if (kill (pid, 0) < 0)
 406         {
 407           EMACS_UNBLOCK_SIGNAL (SIGCHLD);
 408           return;
 409         }
 410       else
 411         /* WARNING: Whatever this macro does *must* not allow SIGCHLD
 412            to happen between the time that it's reenabled and when we
 413            begin to block.  Otherwise we may end up blocking for a
 414            signal that has already arrived and isn't coming again.
 415            Can you say "race condition"?
 416
 417            I assume that the system calls sigpause() or sigsuspend()
 418            to provide this atomicness.  If you're getting hangs in
 419            sigpause()/sigsuspend(), then your OS doesn't implement
 420            this properly (this applies under hpux9, for example).
 421            Try defining BROKEN_WAIT_FOR_SIGNAL. */
 422         EMACS_WAIT_FOR_SIGNAL (SIGCHLD);
 423     }
 424 #else /* not HAVE_WAITPID and not WINDOWSNT and (not EMACS_BLOCK_SIGNAL or BROKEN_WAIT_FOR_SIGNAL) */
 425   /* This approach is kind of cheesy but is guaranteed(?!) to work
 426      for all systems. */
 427   while (1)
 428     {
 429       QUIT;
 430       if (kill (pid, 0) < 0)
 431         return;
 432       emacs_sleep (1);
 433     }
 434 #endif /* OS features */
 435 }
 436
 437
 438 #if !defined (NO_SUBPROCESSES)
 439
 440 /*
 441  *      flush any pending output
 442  *      (may flush input as well; it does not matter the way we use it)
 443  */
 444
 445 void
 446 flush_pending_output (int channel)
 447 {
 448 #ifdef HAVE_TERMIOS
 449   /* If we try this, we get hit with SIGTTIN, because
 450      the child's tty belongs to the child's pgrp. */
 451 #elif defined (TCFLSH)
 452   ioctl (channel, TCFLSH, 1);
 453 #elif defined (TIOCFLUSH)
 454   int zero = 0;
 455   /* 3rd arg should be ignored
 456      but some 4.2 kernels actually want the address of an int
 457      and nonzero means something different.  */
 458   ioctl (channel, TIOCFLUSH, &zero);
 459 #endif
 460 }
 461
 462 #ifndef WINDOWSNT
 463 /*  Set up the terminal at the other end of a pseudo-terminal that
 464     we will be controlling an inferior through.
 465     It should not echo or do line-editing, since that is done
 466     in Emacs.  No padding needed for insertion into an Emacs buffer.  */
 467
 468 void
 469 child_setup_tty (int out)
 470 {
 471   struct emacs_tty s;
 472   emacs_get_tty (out, &s);
 473
 474 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
 475   assert (isatty(out));
 476   s.main.c_oflag |= OPOST;      /* Enable output postprocessing */
 477   s.main.c_oflag &= ~ONLCR;     /* Disable map of NL to CR-NL on output */
 478 #ifdef NLDLY
 479   s.main.c_oflag &= ~(NLDLY|CRDLY|TABDLY|BSDLY|VTDLY|FFDLY);
 480                                 /* No output delays */
 481 #endif
 482   s.main.c_lflag &= ~ECHO;      /* Disable echo */
 483   s.main.c_lflag |= ISIG;       /* Enable signals */
 484 #ifdef IUCLC
 485   s.main.c_iflag &= ~IUCLC;     /* Disable downcasing on input.  */
 486 #endif
 487 #ifdef OLCUC
 488   s.main.c_oflag &= ~OLCUC;     /* Disable upcasing on output.  */
 489 #endif
 490   s.main.c_oflag &= ~TAB3;      /* Disable tab expansion */
 491 #if defined (CSIZE) && defined (CS8)
 492   s.main.c_cflag = (s.main.c_cflag & ~CSIZE) | CS8; /* Don't strip 8th bit */
 493 #endif
 494 #ifdef ISTRIP
 495   s.main.c_iflag &= ~ISTRIP;    /* Don't strip 8th bit on input */
 496 #endif
 497 #if 0
 498   /* Unnecessary as long as ICANON is set */
 499   s.main.c_cc[VMIN]  = 1;       /* minimum number of characters to accept  */
 500   s.main.c_cc[VTIME] = 0;       /* wait forever for at least 1 character  */
 501 #endif /* 0 */
 502
 503   s.main.c_lflag |= ICANON;     /* Enable erase/kill and eof processing */
 504   s.main.c_cc[VEOF] = 04;       /* ensure that EOF is Control-D */
 505   s.main.c_cc[VERASE] = _POSIX_VDISABLE; /* disable erase processing */
 506   s.main.c_cc[VKILL]  = _POSIX_VDISABLE; /* disable kill processing */
 507
 508 #ifdef HPUX
 509   s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
 510 #endif /* HPUX */
 511
 512 #ifdef AIX
 513 #ifndef IBMR2AIX
 514   /* AIX enhanced edit loses NULs, so disable it. */
 515   s.main.c_line = 0;
 516   s.main.c_iflag &= ~ASCEDIT;
 517 #endif /* IBMR2AIX */
 518   /* Also, PTY overloads NUL and BREAK.
 519      don't ignore break, but don't signal either, so it looks like NUL.
 520      This really serves a purpose only if running in an XTERM window
 521      or via TELNET or the like, but does no harm elsewhere.  */
 522   s.main.c_iflag &= ~IGNBRK;
 523   s.main.c_iflag &= ~BRKINT;
 524 #endif /* AIX */
 525 #ifdef SIGNALS_VIA_CHARACTERS
 526   /* TTY `special characters' are used in process_send_signal
 527      so set them here to something useful.  */
 528   s.main.c_cc[VQUIT] = '\\'&037; /* Control-\ */
 529   s.main.c_cc[VINTR] = 'C' &037; /* Control-C */
 530   s.main.c_cc[VSUSP] = 'Z' &037; /* Control-Z */
 531 #else /* no TIOCGPGRP or no TIOCGLTC or no TIOCGETC */
 532   /* TTY `special characters' work better as signals, so disable
 533      character forms */
 534   s.main.c_cc[VQUIT] = _POSIX_VDISABLE;
 535   s.main.c_cc[VINTR] = _POSIX_VDISABLE;
 536   s.main.c_cc[VSUSP] = _POSIX_VDISABLE;
 537   s.main.c_lflag &= ~ISIG;
 538 #endif /* no TIOCGPGRP or no TIOCGLTC or no TIOCGETC */
 539   s.main.c_cc[VEOL] = _POSIX_VDISABLE;
 540 #if defined (CBAUD)
 541   /* <mdiers> #### This is not portable. ###
 542      POSIX does not specify CBAUD, and 4.4BSD does not have it.
 543      Instead, POSIX suggests to use cfset{i,o}speed().
 544      [cf. D. Lewine, POSIX Programmer's Guide, Chapter 8: Terminal
 545      I/O, O'Reilly 1991] */
 546   s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
 547 #else
 548   /* <mdiers> What to do upon failure? Just ignoring rc is probably
 549      not acceptable, is it? */
 550   if (cfsetispeed (&s.main, B9600) == -1) /* ignore */;
 551   if (cfsetospeed (&s.main, B9600) == -1) /* ignore */;
 552 #endif /* defined (CBAUD) */
 553
 554 #else /* not HAVE_TERMIO */
 555
 556   s.main.sg_flags &= ~(ECHO | CRMOD | ANYP | ALLDELAY | RAW | LCASE
 557                        | CBREAK | TANDEM);
 558   s.main.sg_flags |= LPASS8;
 559   s.main.sg_erase = 0377;
 560   s.main.sg_kill  = 0377;
 561   s.lmode = LLITOUT | s.lmode;        /* Don't strip 8th bit */
 562
 563 #endif /* not HAVE_TERMIO */
 564   emacs_set_tty (out, &s, 0);
 565
 566 #ifdef RTU
 567   {
 568     int zero = 0;
 569     ioctl (out, FIOASYNC, &zero);
 570   }
 571 #endif /* RTU */
 572 }
 573 #endif /* WINDOWSNT */
 574
 575 #endif /* not NO_SUBPROCESSES */
 576
 577 \f
 578 #if !defined (SIGTSTP) && !defined (USG_JOBCTRL)
 579
 580 #if defined(__STDC__) || defined(_MSC_VER)
 581 #define SIG_PARAM_TYPE int
 582 #else
 583 #define SIG_PARAM_TYPE
 584 #endif
 585
 586 /* Record a signal code and the handler for it.  */
 587 struct save_signal
 588 {
 589   int code;
 590   SIGTYPE (*handler) (SIG_PARAM_TYPE);
 591 };
 592
 593 static void
 594 save_signal_handlers (struct save_signal *saved_handlers)
 595 {
 596   while (saved_handlers->code)
 597     {
 598       saved_handlers->handler
 599         = (SIGTYPE (*) (SIG_PARAM_TYPE)) signal (saved_handlers->code, SIG_IGN);
 600       saved_handlers++;
 601     }
 602 }
 603
 604 static void
 605 restore_signal_handlers (struct save_signal *saved_handlers)
 606 {
 607   while (saved_handlers->code)
 608     {
 609       signal (saved_handlers->code, saved_handlers->handler);
 610       saved_handlers++;
 611     }
 612 }
 613
 614 #ifdef WINDOWSNT
 615
 616 pid_t
 617 sys_getpid (void)
 618 {
 619   return abs (getpid ());
 620 }
 621
 622 #endif /* WINDOWSNT */
 623
 624 /* Fork a subshell.  */
 625 static void
 626 sys_subshell (void)
 627 {
 628 #ifndef WINDOWSNT
 629   int pid;
 630 #endif
 631   struct save_signal saved_handlers[5];
 632   Lisp_Object dir;
 633   unsigned char *str = 0;
 634   int len;
 635   struct gcpro gcpro1;
 636
 637   saved_handlers[0].code = SIGINT;
 638   saved_handlers[1].code = SIGQUIT;
 639   saved_handlers[2].code = SIGTERM;
 640 #ifdef SIGIO
 641   saved_handlers[3].code = SIGIO;
 642   saved_handlers[4].code = 0;
 643 #else
 644   saved_handlers[3].code = 0;
 645 #endif
 646
 647   /* Mentioning current_buffer->buffer would mean including buffer.h,
 648      which somehow wedges the hp compiler.  So instead...  */
 649
 650   if (NILP (Fboundp (Qdefault_directory)))
 651     goto xyzzy;
 652   dir = Fsymbol_value (Qdefault_directory);
 653   if (!STRINGP (dir))
 654     goto xyzzy;
 655
 656   GCPRO1 (dir);
 657   dir = Funhandled_file_name_directory (dir);
 658   dir = expand_and_dir_to_file (dir, Qnil);
 659   UNGCPRO;
 660   str = (unsigned char *) alloca (XSTRING_LENGTH (dir) + 2);
 661   len = XSTRING_LENGTH (dir);
 662   memcpy (str, XSTRING_DATA (dir), len);
 663   if (!IS_ANY_SEP (str[len - 1]))
 664     str[len++] = DIRECTORY_SEP;
 665   str[len] = 0;
 666  xyzzy:
 667
 668 #ifndef WINDOWSNT
 669   pid = fork ();
 670
 671   if (pid == -1)
 672     error ("Can't spawn subshell");
 673   if (pid == 0)
 674 #endif /* not WINDOWSNT */
 675   {
 676       char *sh = 0;
 677
 678       if (sh == 0)
 679         sh = (char *) egetenv ("SHELL");
 680       if (sh == 0)
 681         sh = "sh";
 682
 683     /* Use our buffer's default directory for the subshell.  */
 684     if (str)
 685       sys_chdir (str);
 686
 687 #ifdef WINDOWSNT
 688
 689     /* Waits for process completion */
 690     if (_spawnlp (_P_WAIT, sh, sh, NULL) != 0)
 691       error ("Can't spawn subshell");
 692     else
 693       return; /* we're done, no need to wait for termination */
 694   }
 695
 696 #else
 697
 698 #if !defined (NO_SUBPROCESSES)
 699     close_process_descs ();     /* Close Emacs's pipes/ptys */
 700 #endif
 701
 702 #ifdef SET_EMACS_PRIORITY
 703     if (emacs_priority != 0)
 704       nice (-emacs_priority);   /* Give the new shell the default priority */
 705 #endif
 706
 707     execlp (sh, sh, 0);
 708     write (1, "Can't execute subshell", 22);
 709     _exit (1);
 710   }
 711
 712   save_signal_handlers (saved_handlers);
 713   synch_process_alive = 1;
 714   wait_for_termination (pid);
 715   restore_signal_handlers (saved_handlers);
 716
 717 #endif /* not WINDOWSNT */
 718
 719 }
 720
 721 #endif /* !defined (SIGTSTP) && !defined (USG_JOBCTRL) */
 722
 723
 724 \f
 725 /* Suspend the Emacs process; give terminal to its superior.  */
 726 void
 727 sys_suspend (void)
 728 {
 729 #if defined (SIGTSTP)
 730   {
 731     int pgrp = EMACS_GET_PROCESS_GROUP ();
 732     EMACS_KILLPG (pgrp, SIGTSTP);
 733   }
 734
 735 #elif defined (USG_JOBCTRL)
 736   /* If you don't know what this is don't mess with it */
 737   ptrace (0, 0, 0, 0);          /* set for ptrace - caught by csh */
 738   kill (getpid (), SIGQUIT);
 739
 740 #else /* No SIGTSTP or USG_JOBCTRL */
 741
 742   /* On a system where suspending is not implemented,
 743      instead fork a subshell and let it talk directly to the terminal
 744      while we wait.  */
 745   sys_subshell ();
 746
 747 #endif
 748 }
 749
 750 /* Suspend a process if possible; give terminal to its superior.  */
 751 void
 752 sys_suspend_process (int process)
 753 {
 754     /* I don't doubt that it is possible to suspend processes on
 755      * VMS machines or thost that use USG_JOBCTRL,
 756      * but I don't know how to do it, so...
 757      */
 758 #if defined (SIGTSTP)
 759     kill(process, SIGTSTP);
 760 #endif
 761 }
 762 \f
 763
 764 /* Given FD, obtain pty buffer size. When no luck, a good guess is made,
 765    so that the function works even when fd is not a pty. */
 766
 767 int
 768 get_pty_max_bytes (int fd)
 769 {
 770   /* DEC OSF 4.0 fpathconf returns 255, but xemacs hangs on long shell
 771      input lines if we return 253.  252 is OK!.  So let's leave a bit
 772      of slack for the newline that xemacs will insert, and for those
 773      inevitable vendor off-by-one-or-two-or-three bugs. */
 774 #define MAX_CANON_SLACK 10
 775 #define SAFE_MAX_CANON (127 - MAX_CANON_SLACK)
 776 #if defined (HAVE_FPATHCONF) && defined (_PC_MAX_CANON)
 777   {
 778     int max_canon = fpathconf (fd, _PC_MAX_CANON);
 779     return (max_canon < 0 ? SAFE_MAX_CANON :
 780             max_canon > SAFE_MAX_CANON ? max_canon - MAX_CANON_SLACK :
 781             max_canon);
 782   }
 783 #elif defined (_POSIX_MAX_CANON)
 784   return (_POSIX_MAX_CANON > SAFE_MAX_CANON ?
 785           _POSIX_MAX_CANON - MAX_CANON_SLACK :
 786           _POSIX_MAX_CANON);
 787 #else
 788   return SAFE_MAX_CANON;
 789 #endif
 790 }
 791
 792 /* Figure out the eof character for the FD. */
 793
 794 Bufbyte
 795 get_eof_char (int fd)
 796 {
 797   const Bufbyte ctrl_d = (Bufbyte) '\004';
 798
 799   if (!isatty (fd))
 800     return ctrl_d;
 801 #ifdef HAVE_TERMIOS
 802   {
 803     struct termios t;
 804     tcgetattr (fd, &t);
 805 #if 0
 806     /* What is the following line designed to do??? -mrb */
 807     if (strlen ((const char *) t.c_cc) < (unsigned int) (VEOF + 1))
 808       return ctrl_d;
 809     else
 810       return (Bufbyte) t.c_cc[VEOF];
 811 #endif
 812     return t.c_cc[VEOF] == _POSIX_VDISABLE ? ctrl_d : (Bufbyte) t.c_cc[VEOF];
 813   }
 814 #else /* ! HAVE_TERMIOS */
 815   /* On Berkeley descendants, the following IOCTL's retrieve the
 816     current control characters.  */
 817 #if defined (TIOCGETC)
 818   {
 819     struct tchars c;
 820     ioctl (fd, TIOCGETC, &c);
 821     return (Bufbyte) c.t_eofc;
 822   }
 823 #else /* ! defined (TIOCGLTC) && defined (TIOCGETC) */
 824   /* On SYSV descendants, the TCGETA ioctl retrieves the current control
 825      characters.  */
 826 #ifdef TCGETA
 827   {
 828     struct termio t;
 829     ioctl (fd, TCGETA, &t);
 830     if (strlen ((const char *) t.c_cc) < (unsigned int) (VINTR + 1))
 831       return ctrl_d;
 832     else
 833       return (Bufbyte) t.c_cc[VINTR];
 834   }
 835 #else /* ! defined (TCGETA) */
 836   /* Rather than complain, we'll just guess ^D, which is what
 837    * earlier emacsen always used. */
 838   return ctrl_d;
 839 #endif /* ! defined (TCGETA) */
 840 #endif /* ! defined (TIOCGETC) */
 841 #endif /* ! defined (HAVE_TERMIOS) */
 842 }
 843
 844 /* Set the logical window size associated with descriptor FD
 845    to HEIGHT and WIDTH.  This is used mainly with ptys.  */
 846
 847 int
 848 set_window_size (int fd, int height, int width)
 849 {
 850 #ifdef TIOCSWINSZ
 851
 852   /* BSD-style.  */
 853   struct winsize size;
 854   size.ws_row = height;
 855   size.ws_col = width;
 856
 857   if (ioctl (fd, TIOCSWINSZ, &size) == -1)
 858     return 0; /* error */
 859   else
 860     return 1;
 861
 862 #elif defined (TIOCSSIZE)
 863
 864   /* SunOS - style.  */
 865   struct ttysize size;
 866   size.ts_lines = height;
 867   size.ts_cols = width;
 868
 869   if (ioctl (fd, TIOCGSIZE, &size) == -1)
 870     return 0;
 871   else
 872     return 1;
 873 #else
 874   return -1;
 875 #endif
 876 }
 877
 878 #ifdef HAVE_PTYS
 879
 880 /* Set up the proper status flags for use of a pty.  */
 881
 882 void
 883 setup_pty (int fd)
 884 {
 885   /* I'm told that TOICREMOTE does not mean control chars
 886      "can't be sent" but rather that they don't have
 887      input-editing or signaling effects.
 888      That should be good, because we have other ways
 889      to do those things in Emacs.
 890      However, telnet mode seems not to work on 4.2.
 891      So TIOCREMOTE is turned off now. */
 892
 893   /* Under hp-ux, if TIOCREMOTE is turned on, some calls
 894      will hang.  In particular, the "timeout" feature (which
 895      causes a read to return if there is no data available)
 896      does this.  Also it is known that telnet mode will hang
 897      in such a way that Emacs must be stopped (perhaps this
 898      is the same problem).
 899
 900      If TIOCREMOTE is turned off, then there is a bug in
 901      hp-ux which sometimes loses data.  Apparently the
 902      code which blocks the master process when the internal
 903      buffer fills up does not work.  Other than this,
 904      though, everything else seems to work fine.
 905
 906      Since the latter lossage is more benign, we may as well
 907      lose that way.  -- cph */
 908 #if defined (FIONBIO) && defined (SYSV_PTYS)
 909   {
 910     int on = 1;
 911     ioctl (fd, FIONBIO, &on);
 912   }
 913 #endif
 914 #ifdef IBMRTAIX
 915   /* On AIX, the parent gets SIGHUP when a pty attached child dies.  So, we */
 916   /* ignore SIGHUP once we've started a child on a pty.  Note that this may */
 917   /* cause EMACS not to die when it should, i.e., when its own controlling  */
 918   /* tty goes away.  I've complained to the AIX developers, and they may    */
 919   /* change this behavior, but I'm not going to hold my breath.             */
 920   signal (SIGHUP, SIG_IGN);
 921 #endif
 922 #ifdef TIOCPKT
 923   /* In some systems (Linux through 2.0.0, at least), packet mode doesn't
 924      get cleared when a pty is closed, so we need to clear it here.
 925      Linux pre2.0.13 contained an attempted fix for this (from Ted Ts'o,
 926      tytso@mit.edu), but apparently it messed up rlogind and telnetd, so he
 927      removed the fix in pre2.0.14.     - dkindred@cs.cmu.edu
 928    */
 929   {
 930     int off = 0;
 931     ioctl (fd, TIOCPKT, (char *)&off);
 932   }
 933 #endif
 934 }
 935 #endif /* HAVE_PTYS */
 936
 937 \f
 938 /************************************************************************/
 939 /*                            TTY control                               */
 940 /************************************************************************/
 941
 942 /* ------------------------------------------------------ */
 943 /*                     get baud rate                      */
 944 /* ------------------------------------------------------ */
 945
 946 /* It really makes more sense for the baud-rate to be console-specific
 947    and not device-specific, but it's (at least potentially) used for output
 948    decisions. */
 949
 950 void
 951 init_baud_rate (struct device *d)
 952 {
 953   struct console *con = XCONSOLE (DEVICE_CONSOLE (d));
 954   if (DEVICE_WIN_P (d) || DEVICE_STREAM_P (d))
 955     {
 956       DEVICE_BAUD_RATE (d) = 38400;
 957       return;
 958     }
 959
 960 #ifdef HAVE_TTY
 961   assert (DEVICE_TTY_P (d));
 962   {
 963     int input_fd = CONSOLE_TTY_DATA (con)->infd;
 964 #if defined (WINDOWSNT)
 965     DEVICE_TTY_DATA (d)->ospeed = 15;
 966 #elif defined (HAVE_TERMIOS)
 967     struct termios sg;
 968
 969     sg.c_cflag = B9600;
 970     tcgetattr (input_fd, &sg);
 971     DEVICE_TTY_DATA (d)->ospeed = cfgetospeed (&sg);
 972 # if defined (USE_GETOBAUD) && defined (getobaud)
 973     /* m88k-motorola-sysv3 needs this (ghazi@noc.rutgers.edu) 9/1/94. */
 974     if (DEVICE_TTY_DATA (d)->ospeed == 0)
 975       DEVICE_TTY_DATA (d)->ospeed = getobaud (sg.c_cflag);
 976 # endif
 977 #elif defined (HAVE_TERMIO)
 978     struct termio sg;
 979
 980     sg.c_cflag = B9600;
 981 # ifdef HAVE_TCATTR
 982     tcgetattr (input_fd, &sg);
 983 # else
 984     ioctl (input_fd, TCGETA, &sg);
 985 # endif
 986     DEVICE_TTY_DATA (d)->ospeed = sg.c_cflag & CBAUD;
 987 #else /* neither TERMIOS nor TERMIO */
 988     struct sgttyb sg;
 989
 990     sg.sg_ospeed = B9600;
 991     if (ioctl (input_fd, TIOCGETP, &sg) < 0)
 992       abort ();
 993     DEVICE_TTY_DATA (d)->ospeed = sg.sg_ospeed;
 994 #endif
 995   }
 996
 997   DEVICE_BAUD_RATE (d) =
 998     (DEVICE_TTY_DATA (d)->ospeed < countof (baud_convert)
 999      ? baud_convert[DEVICE_TTY_DATA (d)->ospeed]
1000      : 9600);
1001
1002   if (DEVICE_BAUD_RATE (d) == 0)
1003     DEVICE_BAUD_RATE (d) = 1200;
1004 #endif /* HAVE_TTY */
1005 }
1006
1007 \f
1008 /* ------------------------------------------------------ */
1009 /*                       SIGIO control                    */
1010 /* ------------------------------------------------------ */
1011
1012 #if defined(SIGIO) && !defined(BROKEN_SIGIO)
1013
1014 static void
1015 init_sigio_on_device (struct device *d)
1016 {
1017   int filedesc = DEVICE_INFD (d);
1018
1019 #if defined (FIOSSAIOOWN)
1020   { /* HPUX stuff */
1021     int owner = getpid ();
1022     int ioctl_status;
1023     if (DEVICE_TTY_P (d))
1024         {
1025           ioctl_status = ioctl (filedesc, FIOGSAIOOWN,
1026                                 &DEVICE_OLD_FCNTL_OWNER (d));
1027           ioctl_status = ioctl (filedesc, FIOSSAIOOWN, &owner);
1028         }
1029 #ifdef HAVE_WINDOW_SYSTEM
1030     else if (!DEVICE_STREAM_P (d))
1031       {
1032         ioctl_status = ioctl (filedesc, SIOCGPGRP,
1033                               &DEVICE_OLD_FCNTL_OWNER (d));
1034         ioctl_status = ioctl (filedesc, SIOCSPGRP, &owner);
1035       }
1036 #endif
1037   }
1038 #elif defined (F_SETOWN) && !defined (F_SETOWN_BUG)
1039   DEVICE_OLD_FCNTL_OWNER (d) = fcntl (filedesc, F_GETOWN, 0);
1040 # ifdef F_SETOWN_SOCK_NEG
1041   /* stdin is a socket here */
1042   fcntl (filedesc, F_SETOWN, -getpid ());
1043 # else
1044   fcntl (filedesc, F_SETOWN, getpid ());
1045 # endif
1046 #endif
1047 }
1048
1049 static void
1050 reset_sigio_on_device (struct device *d)
1051 {
1052   int filedesc = DEVICE_INFD (d);
1053
1054 #if defined (FIOSSAIOOWN)
1055   { /* HPUX stuff */
1056     int ioctl_status;
1057     if (DEVICE_TTY_P (d))
1058       {
1059         ioctl_status = ioctl (filedesc, FIOSSAIOOWN,
1060                               &DEVICE_OLD_FCNTL_OWNER (d));
1061       }
1062 #ifdef HAVE_WINDOW_SYSTEM
1063     else if (!DEVICE_STREAM_P (d))
1064       {
1065         ioctl_status = ioctl (filedesc, SIOCSPGRP,
1066                               &DEVICE_OLD_FCNTL_OWNER (d));
1067       }
1068 #endif
1069   }
1070 #elif defined (F_SETOWN) && !defined (F_SETOWN_BUG)
1071   fcntl (filedesc, F_SETOWN, DEVICE_OLD_FCNTL_OWNER (d));
1072 #endif
1073 }
1074
1075 static void
1076 request_sigio_on_device (struct device *d)
1077 {
1078   int filedesc = DEVICE_INFD (d);
1079
1080 #if defined (I_SETSIG) && !defined(HPUX10) && !defined(LINUX)
1081   {
1082     int events=0;
1083     ioctl (filedesc, I_GETSIG, &events);
1084     ioctl (filedesc, I_SETSIG, events | S_INPUT);
1085   }
1086 #elif defined (FASYNC)
1087   fcntl (filedesc, F_SETFL, fcntl (filedesc, F_GETFL, 0) | FASYNC);
1088 #elif defined (FIOSSAIOSTAT)
1089   {
1090       /* DG: Changed for HP-UX. HP-UX uses different IOCTLs for
1091          sockets and other devices for some bizarre reason. We guess
1092          that an X device is a socket, and tty devices aren't. We then
1093          use the following crud to do the appropriate thing. */
1094     int on = 1;
1095     int ioctl_status;           /* ####DG: check if IOCTL succeeds here. */
1096
1097     if (DEVICE_TTY_P (d))
1098       {
1099         ioctl_status = ioctl (filedesc, FIOSSAIOSTAT, &on);
1100       }
1101 #ifdef HAVE_WINDOW_SYSTEM
1102     else if (!DEVICE_STREAM_P (d))
1103       {
1104         ioctl_status = ioctl (filedesc, FIOASYNC, &on);
1105       }
1106 #endif
1107   }
1108 #elif defined (FIOASYNC)
1109   {
1110     int on = 1;
1111     ioctl (filedesc, FIOASYNC, &on);
1112   }
1113 #endif
1114
1115 #if defined (_CX_UX) /* #### Is this crap necessary? */
1116   EMACS_UNBLOCK_SIGNAL (SIGIO);
1117 #endif
1118 }
1119
1120 static void
1121 unrequest_sigio_on_device (struct device *d)
1122 {
1123   int filedesc = DEVICE_INFD (d);
1124
1125 #if defined (I_SETSIG) && !defined(HPUX10)
1126   {
1127     int events=0;
1128     ioctl (filedesc, I_GETSIG, &events);
1129     ioctl (filedesc, I_SETSIG, events & ~S_INPUT);
1130   }
1131 #elif defined (FASYNC)
1132   fcntl (filedesc, F_SETFL, fcntl (filedesc, F_GETFL, 0) & ~FASYNC);
1133 #elif defined (FIOSSAIOSTAT)
1134   {
1135       /* DG: Changed for HP-UX. HP-UX uses different IOCTLs for
1136          sockets and other devices for some bizarre reason. We guess
1137          that an X device is a socket, and tty devices aren't. We then
1138          use the following crud to do the appropriate thing. */
1139
1140     int off = 0;
1141     int ioctl_status;
1142
1143     /* See comment for request_sigio_on_device */
1144
1145     if (DEVICE_TTY_P (d))
1146       {
1147         ioctl_status = ioctl (filedesc, FIOSSAIOSTAT, &off);
1148       }
1149     else
1150       {
1151         ioctl_status = ioctl (filedesc, FIOASYNC, &off);
1152       }
1153   }
1154 #elif defined (FIOASYNC)
1155   {
1156     int off = 0;
1157     ioctl (filedesc, FIOASYNC, &off);
1158   }
1159 #endif
1160 }
1161
1162 void
1163 request_sigio (void)
1164 {
1165   Lisp_Object devcons, concons;
1166
1167   DEVICE_LOOP_NO_BREAK (devcons, concons)
1168     {
1169       struct device *d;
1170
1171       d = XDEVICE (XCAR (devcons));
1172
1173       if (!DEVICE_STREAM_P (d))
1174         request_sigio_on_device (d);
1175     }
1176 }
1177
1178 void
1179 unrequest_sigio (void)
1180 {
1181   Lisp_Object devcons, concons;
1182
1183   DEVICE_LOOP_NO_BREAK (devcons, concons)
1184     {
1185       struct device *d;
1186
1187       d = XDEVICE (XCAR (devcons));
1188
1189       if (!DEVICE_STREAM_P (d))
1190         unrequest_sigio_on_device (d);
1191     }
1192 }
1193
1194 #endif /* SIGIO */
1195 \f
1196 /* ------------------------------------------------------ */
1197 /*             Changing Emacs's process group             */
1198 /* ------------------------------------------------------ */
1199
1200 /* Saving and restoring the process group of Emacs's terminal.  */
1201
1202 /* On some systems, apparently (?!) Emacs must be in its own process
1203    group in order to receive SIGIO correctly.  On other systems
1204    (e.g. Solaris), it's not required and doing it makes things
1205    get fucked up.  So, we only do it when
1206    SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP is defined.  Basically,
1207    this is only required for BSD 4.2 systems. (Actually, I bet
1208    we don't have to do this at all -- those systems also
1209    required interrupt input, which we don't support.)
1210
1211    If Emacs was in its own process group (i.e. inherited_pgroup ==
1212    getpid ()), then we know we're running under a shell with job
1213    control (Emacs would never be run as part of a pipeline).
1214    Everything is fine.
1215
1216    If Emacs was not in its own process group, then we know we're
1217    running under a shell (or a caller) that doesn't know how to
1218    separate itself from Emacs (like sh).  Emacs must be in its own
1219    process group in order to receive SIGIO correctly.  In this
1220    situation, we put ourselves in our own pgroup, forcibly set the
1221    tty's pgroup to our pgroup, and make sure to restore and reinstate
1222    the tty's pgroup just like any other terminal setting.  If
1223    inherited_group was not the tty's pgroup, then we'll get a
1224    SIGTTmumble when we try to change the tty's pgroup, and a CONT if
1225    it goes foreground in the future, which is what should happen.  */
1226
1227 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1228
1229 static int inherited_pgroup;
1230 static int inherited_tty_pgroup;
1231
1232 #endif
1233
1234 void
1235 munge_tty_process_group (void)
1236 {
1237 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1238   if (noninteractive)
1239     return;
1240
1241   /* Only do this munging if we have a device on the controlling
1242      terminal.  See the large comment below. */
1243
1244   if (CONSOLEP (Vcontrolling_terminal) &&
1245       CONSOLE_LIVE_P (XCONSOLE (Vcontrolling_terminal)))
1246     {
1247       int fd = open ("/dev/tty", O_RDWR, 0);
1248       int me = getpid ();
1249       EMACS_BLOCK_SIGNAL (SIGTTOU);
1250       EMACS_SET_TTY_PROCESS_GROUP (fd, &me);
1251       EMACS_UNBLOCK_SIGNAL (SIGTTOU);
1252       close (fd);
1253     }
1254 #endif
1255 }
1256
1257 /* Split off the foreground process group to Emacs alone.
1258    When we are in the foreground, but not started in our own process
1259    group, redirect the TTY to point to our own process group.  We need
1260    to be in our own process group to receive SIGIO properly.  */
1261 static void
1262 munge_process_groups (void)
1263 {
1264 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1265   if (noninteractive)
1266     return;
1267
1268   EMACS_SEPARATE_PROCESS_GROUP ();
1269
1270   munge_tty_process_group ();
1271 #endif
1272 }
1273
1274 void
1275 unmunge_tty_process_group (void)
1276 {
1277 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1278   {
1279     int fd = open ("/dev/tty", O_RDWR, 0);
1280     EMACS_BLOCK_SIGNAL (SIGTTOU);
1281     EMACS_SET_TTY_PROCESS_GROUP (fd, &inherited_tty_pgroup);
1282     EMACS_UNBLOCK_SIGNAL (SIGTTOU);
1283     close (fd);
1284   }
1285 #endif
1286 }
1287
1288 /* Set the tty to our original foreground group.
1289    Also restore the original process group (put us back into sh's
1290    process group), so that ^Z will suspend both us and sh. */
1291 static void
1292 unmunge_process_groups (void)
1293 {
1294 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1295   if (noninteractive)
1296     return;
1297
1298   unmunge_tty_process_group ();
1299
1300   EMACS_SET_PROCESS_GROUP (inherited_pgroup);
1301 #endif
1302 }
1303
1304 /* According to some old wisdom, we need to be in a separate process
1305    group for SIGIO to work correctly (at least on some systems ...).
1306    So go ahead and put ourselves into our own process group.  This
1307    will fail if we're already in our own process group, but who cares.
1308    Also record whether we were in our own process group. (In general,
1309    we will already be in our own process group if we were started from
1310    a job-control shell like csh, but not if we were started from sh).
1311
1312    If we succeeded in changing our process group, then we will no
1313    longer be in the foreground process group of our controlling
1314    terminal.  Therefore, if we have a console open onto this terminal,
1315    we have to change the controlling terminal's foreground process
1316    group (otherwise we will get stopped with a SIGTTIN signal when
1317    attempting to read from the terminal).  It's important,
1318    however, that we do this *only* when we have a console open onto
1319    the terminal.  It's a decidedly bad idea to do so otherwise,
1320    especially if XEmacs was started from the background. */
1321
1322 void
1323 init_process_group (void)
1324 {
1325 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1326   if (! noninteractive)
1327     {
1328       int fd = open ("/dev/tty", O_RDWR, 0);
1329       inherited_pgroup = EMACS_GET_PROCESS_GROUP ();
1330       EMACS_GET_TTY_PROCESS_GROUP (fd, &inherited_tty_pgroup);
1331       close (fd);
1332       EMACS_SEPARATE_PROCESS_GROUP ();
1333     }
1334 #endif
1335 }
1336
1337 void
1338 disconnect_controlling_terminal (void)
1339 {
1340 #  ifdef HAVE_SETSID
1341   /* Controlling terminals are attached to a session.
1342      Create a new session for us; it will have no controlling
1343      terminal.  This also, of course, puts us in our own
1344      process group. */
1345   setsid ();
1346 #  else
1347   /* Put us in our own process group. */
1348   EMACS_SEPARATE_PROCESS_GROUP ();
1349 #    if defined (TIOCNOTTY)
1350   /* This is the older way of disconnecting the controlling
1351      terminal, on 4.3 BSD.  We must open /dev/tty; using
1352      filedesc 0 is not sufficient because it could be
1353      something else (e.g. our stdin was redirected to
1354      another terminal).
1355      */
1356   {
1357     int j = open ("/dev/tty", O_RDWR, 0);
1358     ioctl (j, TIOCNOTTY, 0);
1359     close (j);
1360   }
1361 #    endif /* TIOCNOTTY */
1362   /*
1363      On systems without TIOCNOTTY and without
1364      setsid(), we don't need to do anything more to
1365      disconnect our controlling terminal.  Here is
1366      what the man page for termio(7) from a SYSV 3.2
1367      system says:
1368
1369      "The first terminal file opened by the process group leader
1370      of a terminal file not already associated with a process
1371      group becomes the control terminal for that process group.
1372      The control terminal plays a special role in handling quit
1373      and interrupt signals, as discussed below.  The control
1374      terminal is inherited by a child process during a fork(2).
1375      A process can break this association by changing its process
1376      group using setpgrp(2)."
1377
1378      */
1379 #  endif /* not HAVE_SETSID */
1380 }
1381
1382 \f
1383 /* ------------------------------------------------------ */
1384 /*        Getting and setting emacs_tty structures        */
1385 /* ------------------------------------------------------ */
1386
1387 /* It's wrong to encase these into #ifdef HAVE_TTY because we need
1388    them for child TTY processes.  */
1389 /* However, this does break NT support while we don't do child TTY processes */
1390 #ifndef WINDOWSNT
1391
1392 /* Set *TC to the parameters associated with the terminal FD.
1393    Return zero if all's well, or -1 if we ran into an error we
1394    couldn't deal with.  */
1395 int
1396 emacs_get_tty (int fd, struct emacs_tty *settings)
1397 {
1398   /* Retrieve the primary parameters - baud rate, character size, etcetera.  */
1399 #ifdef HAVE_TCATTR
1400   /* We have those nifty POSIX tcmumbleattr functions.  */
1401   if (tcgetattr (fd, &settings->main) < 0)
1402     return -1;
1403
1404 #elif defined HAVE_TERMIO
1405   /* The SYSV-style interface?  */
1406   if (ioctl (fd, TCGETA, &settings->main) < 0)
1407     return -1;
1408
1409 #elif !defined (WINDOWSNT)
1410   /* I give up - I hope you have the BSD ioctls.  */
1411   if (ioctl (fd, TIOCGETP, &settings->main) < 0)
1412     return -1;
1413 #endif /* HAVE_TCATTR */
1414
1415   /* Suivant - Do we have to get struct ltchars data?  */
1416 #ifdef HAVE_LTCHARS
1417   if (ioctl (fd, TIOCGLTC, &settings->ltchars) < 0)
1418     return -1;
1419 #endif
1420
1421   /* How about a struct tchars and a wordful of lmode bits?  */
1422 #ifdef HAVE_TCHARS
1423   if (ioctl (fd, TIOCGETC, &settings->tchars) < 0
1424       || ioctl (fd, TIOCLGET, &settings->lmode) < 0)
1425     return -1;
1426 #endif
1427
1428   /* We have survived the tempest.  */
1429   return 0;
1430 }
1431
1432 /* Set the parameters of the tty on FD according to the contents of
1433    *SETTINGS.  If FLUSHP is non-zero, we discard input.
1434    Return 0 if all went well, and -1 if anything failed.
1435    #### All current callers use FLUSHP == 0. */
1436
1437 int
1438 emacs_set_tty (int fd, struct emacs_tty *settings, int flushp)
1439 {
1440   /* Set the primary parameters - baud rate, character size, etcetera.  */
1441 #ifdef HAVE_TCATTR
1442   int i;
1443   /* We have those nifty POSIX tcmumbleattr functions.
1444      William J. Smith <wjs@wiis.wang.com> writes:
1445      "POSIX 1003.1 defines tcsetattr() to return success if it was
1446      able to perform any of the requested actions, even if some
1447      of the requested actions could not be performed.
1448      We must read settings back to ensure tty setup properly.
1449      AIX requires this to keep tty from hanging occasionally."  */
1450   /* This makes sure that we don't loop indefinitely in here.  */
1451   for (i = 0 ; i < 10 ; i++)
1452     if (tcsetattr (fd, flushp ? TCSAFLUSH : TCSADRAIN, &settings->main) < 0)
1453       {
1454         if (errno == EINTR)
1455           continue;
1456         else
1457           return -1;
1458       }
1459     else
1460       {
1461         struct termios new;
1462
1463         /* Get the current settings, and see if they're what we asked for.  */
1464         tcgetattr (fd, &new);
1465         /* We cannot use memcmp on the whole structure here because under
1466          * aix386 the termios structure has some reserved field that may
1467          * not be filled in.
1468          */
1469         if (   new.c_iflag == settings->main.c_iflag
1470             && new.c_oflag == settings->main.c_oflag
1471             && new.c_cflag == settings->main.c_cflag
1472             && new.c_lflag == settings->main.c_lflag
1473             && memcmp(new.c_cc, settings->main.c_cc, NCCS) == 0)
1474           break;
1475         else
1476           continue;
1477       }
1478 #elif defined HAVE_TERMIO
1479   /* The SYSV-style interface?  */
1480   if (ioctl (fd, flushp ? TCSETAF : TCSETAW, &settings->main) < 0)
1481     return -1;
1482
1483 #elif !defined (WINDOWSNT)
1484   /* I give up - I hope you have the BSD ioctls.  */
1485   if (ioctl (fd, (flushp) ? TIOCSETP : TIOCSETN, &settings->main) < 0)
1486     return -1;
1487 #endif /* HAVE_TCATTR */
1488
1489   /* Suivant - Do we have to get struct ltchars data?  */
1490 #ifdef HAVE_LTCHARS
1491   if (ioctl (fd, TIOCSLTC, &settings->ltchars) < 0)
1492     return -1;
1493 #endif
1494
1495   /* How about a struct tchars and a wordful of lmode bits?  */
1496 #ifdef HAVE_TCHARS
1497   if (ioctl (fd, TIOCSETC, &settings->tchars) < 0
1498       || ioctl (fd, TIOCLSET, &settings->lmode) < 0)
1499     return -1;
1500 #endif
1501
1502   /* We have survived the tempest.  */
1503   return 0;
1504 }
1505
1506 #endif /* WINDOWSNT */
1507 \f
1508 /* ------------------------------------------------------ */
1509 /*                 Initializing a device                  */
1510 /* ------------------------------------------------------ */
1511
1512 #ifdef HAVE_TTY
1513
1514 /* This may also be defined in stdio,
1515    but if so, this does no harm,
1516    and using the same name avoids wasting the other one's space.  */
1517
1518 #if ((defined(USG) || defined(DGUX)) && !defined(__STDC__))
1519 char _sobuf[BUFSIZ+8];
1520 #elif (defined(USG) && !defined(LINUX) && !defined(_SCO_DS)) || defined(IRIX5)
1521 extern unsigned char _sobuf[BUFSIZ+8];
1522 #else
1523 char _sobuf[BUFSIZ];
1524 #endif
1525
1526 #if defined (TIOCGLTC) && defined (HAVE_LTCHARS) /* HAVE_LTCHARS */
1527 static struct ltchars new_ltchars = {-1,-1,-1,-1,-1,-1};
1528 #endif
1529 #ifdef TIOCGETC /* HAVE_TCHARS */
1530 #ifdef HAVE_TCHARS
1531 static struct tchars new_tchars = {-1,-1,-1,-1,-1,-1};
1532 #endif
1533 #endif
1534
1535 static void
1536 tty_init_sys_modes_on_device (struct device *d)
1537 {
1538   struct emacs_tty tty;
1539   int input_fd, output_fd;
1540   struct console *con = XCONSOLE (DEVICE_CONSOLE (d));
1541
1542   input_fd = CONSOLE_TTY_DATA (con)->infd;
1543   output_fd = CONSOLE_TTY_DATA (con)->outfd;
1544
1545   emacs_get_tty (input_fd, &CONSOLE_TTY_DATA (con)->old_tty);
1546   tty = CONSOLE_TTY_DATA (con)->old_tty;
1547
1548   con->tty_erase_char = Qnil;
1549
1550 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
1551   /* after all those years... */
1552   con->tty_erase_char = make_char (tty.main.c_cc[VERASE]);
1553 #ifdef DGUX
1554   /* This allows meta to be sent on 8th bit.  */
1555   tty.main.c_iflag &= ~INPCK;   /* don't check input for parity */
1556 #endif
1557   tty.main.c_iflag |= (IGNBRK); /* Ignore break condition */
1558   tty.main.c_iflag &= ~ICRNL;   /* Disable map of CR to NL on input */
1559 #ifdef ISTRIP
1560   tty.main.c_iflag &= ~ISTRIP;  /* don't strip 8th bit on input */
1561 #endif
1562   tty.main.c_lflag &= ~ECHO;    /* Disable echo */
1563   tty.main.c_lflag &= ~ICANON;  /* Disable erase/kill processing */
1564 #ifdef IEXTEN
1565   tty.main.c_lflag &= ~IEXTEN;  /* Disable other editing characters.  */
1566 #endif
1567   tty.main.c_lflag |= ISIG;     /* Enable signals */
1568   if (TTY_FLAGS (con).flow_control)
1569     {
1570       tty.main.c_iflag |= IXON; /* Enable start/stop output control */
1571 #ifdef IXANY
1572       tty.main.c_iflag &= ~IXANY;
1573 #endif /* IXANY */
1574     }
1575   else
1576     tty.main.c_iflag &= ~IXON;  /* Disable start/stop output control */
1577   tty.main.c_oflag &= ~ONLCR;   /* Disable map of NL to CR-NL
1578                                    on output */
1579   tty.main.c_oflag &= ~TAB3;    /* Disable tab expansion */
1580 #ifdef CS8
1581   if (TTY_FLAGS (con).meta_key)
1582     {
1583       tty.main.c_cflag |= CS8;  /* allow 8th bit on input */
1584       tty.main.c_cflag &= ~PARENB;/* Don't check parity */
1585     }
1586 #endif
1587   if (CONSOLE_TTY_DATA (con)->controlling_terminal)
1588     {
1589       tty.main.c_cc[VINTR] =
1590         CONSOLE_QUIT_CHAR (con); /* C-g (usually) gives SIGINT */
1591       /* Set up C-g for both SIGQUIT and SIGINT.
1592          We don't know which we will get, but we handle both alike
1593          so which one it really gives us does not matter.  */
1594       tty.main.c_cc[VQUIT] = CONSOLE_QUIT_CHAR (con);
1595     }
1596   else
1597     {
1598       tty.main.c_cc[VINTR] = _POSIX_VDISABLE;
1599       tty.main.c_cc[VQUIT] = _POSIX_VDISABLE;
1600     }
1601   tty.main.c_cc[VMIN] = 1;      /* Input should wait for at
1602                                    least 1 char */
1603   tty.main.c_cc[VTIME] = 0;     /* no matter how long that takes.  */
1604 #ifdef VSWTCH
1605   tty.main.c_cc[VSWTCH] = _POSIX_VDISABLE; /* Turn off shell layering use
1606                                               of C-z */
1607 #endif /* VSWTCH */
1608   /* There was some conditionalizing here on (mips or TCATTR), but
1609      I think that's wrong.  There was one report of C-y (DSUSP) not being
1610      disabled on HP9000s700 systems, and this might fix it. */
1611 #ifdef VSUSP
1612   tty.main.c_cc[VSUSP] = _POSIX_VDISABLE; /* Turn off mips handling of C-z. */
1613 #endif /* VSUSP */
1614 #ifdef V_DSUSP
1615   tty.main.c_cc[V_DSUSP] = _POSIX_VDISABLE; /* Turn off mips handling of C-y. */
1616 #endif /* V_DSUSP */
1617 #ifdef VDSUSP /* Some systems have VDSUSP, some have V_DSUSP.  */
1618   tty.main.c_cc[VDSUSP] = _POSIX_VDISABLE;
1619 #endif /* VDSUSP */
1620 #ifdef VLNEXT
1621   tty.main.c_cc[VLNEXT] = _POSIX_VDISABLE;
1622 #endif /* VLNEXT */
1623 #ifdef VREPRINT
1624   tty.main.c_cc[VREPRINT] = _POSIX_VDISABLE;
1625 #endif /* VREPRINT */
1626 #ifdef VWERASE
1627   tty.main.c_cc[VWERASE] = _POSIX_VDISABLE;
1628 #endif /* VWERASE */
1629 #ifdef VDISCARD
1630   tty.main.c_cc[VDISCARD] = _POSIX_VDISABLE;
1631 #endif /* VDISCARD */
1632 #ifdef VSTART
1633   tty.main.c_cc[VSTART] = _POSIX_VDISABLE;
1634 #endif /* VSTART */
1635 #ifdef VSTRT
1636   tty.main.c_cc[VSTRT] = _POSIX_VDISABLE; /* called VSTRT on some systems */
1637 #endif /* VSTART */
1638 #ifdef VSTOP
1639   tty.main.c_cc[VSTOP] = _POSIX_VDISABLE;
1640 #endif /* VSTOP */
1641 #ifdef SET_LINE_DISCIPLINE
1642   /* Need to explicitly request TERMIODISC line discipline or
1643      Ultrix's termios does not work correctly.  */
1644   tty.main.c_line = SET_LINE_DISCIPLINE;
1645 #endif
1646
1647 #ifdef AIX
1648 #ifndef IBMR2AIX
1649   /* AIX enhanced edit loses NULs, so disable it. */
1650   tty.main.c_line = 0;
1651   tty.main.c_iflag &= ~ASCEDIT;
1652 #else
1653   tty.main.c_cc[VSTRT] = 255;
1654   tty.main.c_cc[VSTOP] = 255;
1655   tty.main.c_cc[VSUSP] = 255;
1656   tty.main.c_cc[VDSUSP] = 255;
1657 #endif /* IBMR2AIX */
1658   /* Also, PTY overloads NUL and BREAK.
1659      don't ignore break, but don't signal either, so it looks like NUL.
1660      This really serves a purpose only if running in an XTERM window
1661      or via TELNET or the like, but does no harm elsewhere.  */
1662   tty.main.c_iflag &= ~IGNBRK;
1663   tty.main.c_iflag &= ~BRKINT;
1664 #endif /* AIX */
1665 #else /* if not HAVE_TERMIO */
1666 #if !defined (WINDOWSNT)
1667   con->tty_erase_char = make_char (tty.main.sg_erase);
1668   tty.main.sg_flags &= ~(ECHO | CRMOD | XTABS);
1669   if (TTY_FLAGS (con).meta_key)
1670     tty.main.sg_flags |= ANYP;
1671   /* #### should we be using RAW mode here? */
1672   tty.main.sg_flags |= /* interrupt_input ? RAW : */ CBREAK;
1673 #endif /* not WINDOWSNT */
1674 #endif /* not HAVE_TERMIO */
1675
1676   /* If going to use CBREAK mode, we must request C-g to interrupt
1677      and turn off start and stop chars, etc.  If not going to use
1678      CBREAK mode, do this anyway so as to turn off local flow
1679      control for user coming over network on 4.2; in this case,
1680      only t_stopc and t_startc really matter.  */
1681 #ifndef HAVE_TERMIO
1682 #ifdef HAVE_TCHARS
1683   /* Note: if not using CBREAK mode, it makes no difference how we
1684      set this */
1685   tty.tchars = new_tchars;
1686   tty.tchars.t_intrc = CONSOLE_QUIT_CHAR (con);
1687   if (TTY_FLAGS (con).flow_control)
1688     {
1689       tty.tchars.t_startc = '\021';
1690       tty.tchars.t_stopc = '\023';
1691     }
1692
1693   tty.lmode = LDECCTQ | LLITOUT | LPASS8 | LNOFLSH |
1694     CONSOLE_TTY_DATA (con)->old_tty.lmode;
1695
1696 #if defined (ultrix) || defined (__bsdi__)
1697   /* Under Ultrix 4.2a, leaving this out doesn't seem to hurt
1698      anything, and leaving it in breaks the meta key.  Go figure.  */
1699   /* Turning off ONLCR is enough under BSD/386.  Leave the general
1700      output post-processing flag alone since for some reason it
1701      doesn't get reset after XEmacs goes away. */
1702   tty.lmode &= ~LLITOUT;
1703 #endif
1704
1705 #endif /* HAVE_TCHARS */
1706 #endif /* not HAVE_TERMIO */
1707
1708 #ifdef HAVE_LTCHARS
1709   tty.ltchars = new_ltchars;
1710 #endif /* HAVE_LTCHARS */
1711
1712   emacs_set_tty (input_fd, &tty, 0);
1713
1714   /* This code added to insure that, if flow-control is not to be used,
1715      we have an unlocked terminal at the start. */
1716
1717 #ifdef TCXONC
1718   if (!TTY_FLAGS (con).flow_control) ioctl (input_fd, TCXONC, 1);
1719 #endif
1720 #ifdef TIOCSTART
1721   if (!TTY_FLAGS (con).flow_control) ioctl (input_fd, TIOCSTART, 0);
1722 #endif
1723
1724 #if defined (HAVE_TERMIOS) || defined (HPUX9)
1725 #ifdef TCOON
1726   if (!TTY_FLAGS (con).flow_control) tcflow (input_fd, TCOON);
1727 #endif
1728 #endif
1729 #ifdef AIXHFT
1730   hft_init (con);
1731 #ifdef IBMR2AIX
1732   {
1733     /* IBM's HFT device usually thinks a ^J should be LF/CR.
1734        We need it to be only LF.  This is the way that is
1735        done. */
1736     struct termio tty;
1737
1738     if (ioctl (output_fd, HFTGETID, &tty) != -1)
1739       write (output_fd, "\033[20l", 5);
1740   }
1741 #endif
1742 #endif
1743
1744 #if 0 /* We do our own buffering with lstreams. */
1745 #ifdef _IOFBF
1746   /* This symbol is defined on recent USG systems.
1747      Someone says without this call USG won't really buffer the file
1748      even with a call to setbuf. */
1749   setvbuf (CONSOLE_TTY_DATA (con)->outfd, (char *) _sobuf, _IOFBF, sizeof _sobuf);
1750 #else
1751   setbuf (CONSOLE_TTY_DATA (con)->outfd, (char *) _sobuf);
1752 #endif
1753 #endif
1754   set_tty_modes (con);
1755 }
1756
1757 #endif /* HAVE_TTY */
1758
1759 void
1760 init_one_device (struct device *d)
1761 {
1762 #ifdef HAVE_TTY
1763   if (DEVICE_TTY_P (d))
1764     tty_init_sys_modes_on_device (d);
1765 #endif
1766 #if defined(SIGIO) && !defined(BROKEN_SIGIO)
1767   if (!DEVICE_STREAM_P (d))
1768     {
1769       init_sigio_on_device (d);
1770       request_sigio_on_device (d);
1771     }
1772 #endif
1773 }
1774
1775 void
1776 init_one_console (struct console *con)
1777 {
1778   Lisp_Object devcons;
1779
1780   CONSOLE_DEVICE_LOOP (devcons, con)
1781     {
1782       struct device *d = XDEVICE (XCAR (devcons));
1783
1784       init_one_device (d);
1785     }
1786 }
1787
1788 void
1789 reinit_initial_console (void)
1790 {
1791   munge_process_groups ();
1792   if (CONSOLEP (Vcontrolling_terminal) &&
1793       CONSOLE_LIVE_P (XCONSOLE (Vcontrolling_terminal)))
1794     init_one_console (XCONSOLE (Vcontrolling_terminal));
1795 }
1796
1797 \f
1798 /* ------------------------------------------------------ */
1799 /*                   Other TTY functions                  */
1800 /* ------------------------------------------------------ */
1801
1802 #ifdef HAVE_TTY
1803
1804 #if 0 /* not currently used */
1805
1806 /* Return nonzero if safe to use tabs in output.
1807    At the time this is called, init_sys_modes has not been done yet.  */
1808
1809 int
1810 tabs_safe_p (struct device *d)
1811 {
1812 #ifdef HAVE_TTY
1813   if (DEVICE_TTY_P (d))
1814     {
1815       struct emacs_tty tty;
1816
1817       emacs_get_tty (DEVICE_INFD (d), &tty);
1818       return EMACS_TTY_TABS_OK (&tty);
1819     }
1820 #endif
1821   return 1;
1822 }
1823
1824 #endif /* 0 */
1825
1826 /* Get terminal size from system.
1827    Store number of lines into *heightp and width into *widthp.
1828    If zero or a negative number is stored, the value is not valid.  */
1829
1830 void
1831 get_tty_device_size (struct device *d, int *widthp, int *heightp)
1832 {
1833   int input_fd = DEVICE_INFD (d);
1834
1835   assert (DEVICE_TTY_P (d));
1836
1837 #ifdef TIOCGWINSZ
1838   {
1839     /* BSD-style.  */
1840     struct winsize size;
1841
1842     if (ioctl (input_fd, TIOCGWINSZ, &size) == -1)
1843       *widthp = *heightp = 0;
1844     else
1845       {
1846         *widthp = size.ws_col;
1847         *heightp = size.ws_row;
1848       }
1849   }
1850 #elif defined TIOCGSIZE
1851   {
1852     /* SunOS - style.  */
1853     struct ttysize size;
1854
1855     if (ioctl (input_fd, TIOCGSIZE, &size) == -1)
1856       *widthp = *heightp = 0;
1857     else
1858       {
1859         *widthp = size.ts_cols;
1860         *heightp = size.ts_lines;
1861       }
1862   }
1863 #else /* system doesn't know size */
1864
1865   *widthp = 0;
1866   *heightp = 0;
1867
1868 #endif /* not !TIOCGWINSZ */
1869 }
1870
1871 #endif /* HAVE_TTY */
1872
1873 \f
1874 /* ------------------------------------------------------ */
1875 /*                   Is device 8 bit ?                    */
1876 /* ------------------------------------------------------ */
1877
1878 #ifdef HAVE_TTY
1879
1880 int
1881 eight_bit_tty (struct device *d)
1882 {
1883   struct emacs_tty s;
1884   int input_fd;
1885   int eight_bit = 0;
1886
1887   assert (DEVICE_TTY_P (d));
1888   input_fd = DEVICE_INFD (d);
1889
1890   emacs_get_tty (input_fd, &s);
1891
1892 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
1893   eight_bit = (s.main.c_cflag & CSIZE) == CS8;
1894 #else
1895   eight_bit = 0;        /* I don't know how to do it */
1896 #endif
1897   return eight_bit;
1898 }
1899
1900 #endif /* HAVE_TTY */
1901
1902 \f
1903 /* ------------------------------------------------------ */
1904 /*                   Resetting a device                   */
1905 /* ------------------------------------------------------ */
1906
1907 #ifdef HAVE_TTY
1908
1909 /* Prepare the terminal for exiting Emacs; move the cursor to the
1910    bottom of the frame, turn off interrupt-driven I/O, etc.  */
1911 static void
1912 tty_reset_sys_modes_on_device (struct device *d)
1913 {
1914   int input_fd, output_fd;
1915   struct console *con = XCONSOLE (DEVICE_CONSOLE (d));
1916
1917   input_fd = CONSOLE_TTY_DATA (con)->infd;
1918   output_fd = CONSOLE_TTY_DATA (con)->outfd;
1919
1920 #if defined (IBMR2AIX) && defined (AIXHFT)
1921   {
1922     /* HFT consoles normally use ^J as a LF/CR.  We forced it to
1923        do the LF only.  Now, we need to reset it. */
1924     struct termio tty;
1925
1926     if (ioctl (output_fd, HFTGETID, &tty) != -1)
1927       write (output_fd, "\033[20h", 5);
1928   }
1929 #endif
1930
1931   tty_redisplay_shutdown (con);
1932   /* reset_tty_modes() flushes the connection at its end. */
1933   reset_tty_modes (con);
1934
1935 #if defined (BSD)
1936   /* Avoid possible loss of output when changing terminal modes.  */
1937   fsync (output_fd);
1938 #endif
1939
1940   while (emacs_set_tty (input_fd, &CONSOLE_TTY_DATA (con)->old_tty, 0)
1941          < 0 && errno == EINTR)
1942     ;
1943
1944 #ifdef SET_LINE_DISCIPLINE
1945   /* Ultrix's termios *ignores* any line discipline except TERMIODISC.
1946      A different old line discipline is therefore not restored, yet.
1947      Restore the old line discipline by hand.  */
1948   ioctl (input_fd, TIOCSETD, &old_tty.main.c_line);
1949 #endif
1950
1951 #ifdef AIXHFT
1952   hft_reset (con);
1953 #endif
1954
1955 }
1956
1957 #endif /* HAVE_TTY */
1958
1959 void
1960 reset_one_device (struct device *d)
1961 {
1962 #ifdef HAVE_TTY
1963   if (DEVICE_TTY_P (d))
1964     tty_reset_sys_modes_on_device (d);
1965   else
1966 #endif
1967   if (DEVICE_STREAM_P (d))
1968     fflush (CONSOLE_STREAM_DATA (XCONSOLE (DEVICE_CONSOLE (d)))->out);
1969 #if defined(SIGIO) && !defined(BROKEN_SIGIO)
1970   if (!DEVICE_STREAM_P (d))
1971     {
1972       unrequest_sigio_on_device (d);
1973       reset_sigio_on_device (d);
1974     }
1975 #endif
1976 }
1977
1978 void
1979 reset_one_console (struct console *con)
1980 {
1981   /* Note: this can be called during GC. */
1982   Lisp_Object devcons;
1983
1984   CONSOLE_DEVICE_LOOP (devcons, con)
1985     {
1986       struct device *d = XDEVICE (XCAR (devcons));
1987
1988       reset_one_device (d);
1989     }
1990 }
1991
1992 void
1993 reset_all_consoles (void)
1994 {
1995   /* Note: this can be called during GC. */
1996   Lisp_Object concons;
1997
1998   CONSOLE_LOOP (concons)
1999     {
2000       struct console *con = XCONSOLE (XCAR (concons));
2001
2002       reset_one_console (con);
2003     }
2004
2005   unmunge_process_groups ();
2006 }
2007
2008 void
2009 reset_initial_console (void)
2010 {
2011   if (CONSOLEP (Vcontrolling_terminal) &&
2012       CONSOLE_LIVE_P (XCONSOLE (Vcontrolling_terminal)))
2013     reset_one_console (XCONSOLE (Vcontrolling_terminal));
2014   unmunge_process_groups ();
2015 }
2016
2017 \f
2018 /* ------------------------------------------------------ */
2019 /*                 extra TTY stuff under AIX              */
2020 /* ------------------------------------------------------ */
2021
2022 #ifdef AIXHFT
2023
2024 /* Called from init_sys_modes.  */
2025 static void
2026 hft_init (struct console *con)
2027 {
2028   int junk;
2029   int input_fd;
2030
2031   assert (CONSOLE_TTY_P (con));
2032   input_fd = CONSOLE_TTY_DATA (con)->infd;
2033
2034   /* If we're not on an HFT we shouldn't do any of this.  We determine
2035      if we are on an HFT by trying to get an HFT error code.  If this
2036      call fails, we're not on an HFT. */
2037 #ifdef IBMR2AIX
2038   if (ioctl (input_fd, HFQERROR, &junk) < 0)
2039     return;
2040 #else /* not IBMR2AIX */
2041   if (ioctl (input_fd, HFQEIO, 0) < 0)
2042     return;
2043 #endif /* not IBMR2AIX */
2044
2045   /* On AIX the default hft keyboard mapping uses backspace rather than delete
2046      as the rubout key's ASCII code.  Here this is changed.  The bug is that
2047      there's no way to determine the old mapping, so in reset_one_console
2048      we need to assume that the normal map had been present.  Of course, this
2049      code also doesn't help if on a terminal emulator which doesn't understand
2050      HFT VTD's. */
2051   {
2052     struct hfbuf buf;
2053     struct hfkeymap keymap;
2054
2055     buf.hf_bufp = (char *)&keymap;
2056     buf.hf_buflen = sizeof (keymap);
2057     keymap.hf_nkeys = 2;
2058     keymap.hfkey[0].hf_kpos = 15;
2059     keymap.hfkey[0].hf_kstate = HFMAPCHAR | HFSHFNONE;
2060 #ifdef IBMR2AIX
2061     keymap.hfkey[0].hf_keyidh = '<';
2062 #else /* not IBMR2AIX */
2063     keymap.hfkey[0].hf_page = '<';
2064 #endif /* not IBMR2AIX */
2065     keymap.hfkey[0].hf_char = 127;
2066     keymap.hfkey[1].hf_kpos = 15;
2067     keymap.hfkey[1].hf_kstate = HFMAPCHAR | HFSHFSHFT;
2068 #ifdef IBMR2AIX
2069     keymap.hfkey[1].hf_keyidh = '<';
2070 #else /* not IBMR2AIX */
2071     keymap.hfkey[1].hf_page = '<';
2072 #endif /* not IBMR2AIX */
2073     keymap.hfkey[1].hf_char = 127;
2074     hftctl (input_fd, HFSKBD, &buf);
2075   }
2076   /* #### Should probably set a console TTY flag here. */
2077 #if 0
2078   /* The HFT system on AIX doesn't optimize for scrolling, so it's really ugly
2079      at times. */
2080   line_ins_del_ok = char_ins_del_ok = 0;
2081 #endif /* 0 */
2082 }
2083
2084 /* Reset the rubout key to backspace. */
2085
2086 static void
2087 hft_reset (struct console *con)
2088 {
2089   struct hfbuf buf;
2090   struct hfkeymap keymap;
2091   int junk;
2092   int input_fd;
2093
2094   assert (CONSOLE_TTY_P (con));
2095   input_fd = CONSOLE_TTY_DATA (con)->infd;
2096
2097 #ifdef IBMR2AIX
2098   if (ioctl (input_fd, HFQERROR, &junk) < 0)
2099     return;
2100 #else /* not IBMR2AIX */
2101   if (ioctl (input_fd, HFQEIO, 0) < 0)
2102     return;
2103 #endif /* not IBMR2AIX */
2104
2105   buf.hf_bufp = (char *)&keymap;
2106   buf.hf_buflen = sizeof (keymap);
2107   keymap.hf_nkeys = 2;
2108   keymap.hfkey[0].hf_kpos = 15;
2109   keymap.hfkey[0].hf_kstate = HFMAPCHAR | HFSHFNONE;
2110 #ifdef IBMR2AIX
2111   keymap.hfkey[0].hf_keyidh = '<';
2112 #else /* not IBMR2AIX */
2113   keymap.hfkey[0].hf_page = '<';
2114 #endif /* not IBMR2AIX */
2115   keymap.hfkey[0].hf_char = 8;
2116   keymap.hfkey[1].hf_kpos = 15;
2117   keymap.hfkey[1].hf_kstate = HFMAPCHAR | HFSHFSHFT;
2118 #ifdef IBMR2AIX
2119   keymap.hfkey[1].hf_keyidh = '<';
2120 #else /* not IBMR2AIX */
2121   keymap.hfkey[1].hf_page = '<';
2122 #endif /* not IBMR2AIX */
2123   keymap.hfkey[1].hf_char = 8;
2124   hftctl (input_fd, HFSKBD, &buf);
2125 }
2126
2127 #endif /* AIXHFT */
2128
2129 \f
2130 /************************************************************************/
2131 /*                    limits of text/data segments                      */
2132 /************************************************************************/
2133
2134 #if !defined(CANNOT_DUMP) && !defined(PDUMP)
2135 #define NEED_STARTS
2136 #endif
2137
2138 #ifndef SYSTEM_MALLOC
2139 #ifndef NEED_STARTS
2140 #define NEED_STARTS
2141 #endif
2142 #endif
2143
2144 #ifdef NEED_STARTS
2145 /* Some systems that cannot dump also cannot implement these.  */
2146
2147 /*
2148  *      Return the address of the start of the text segment prior to
2149  *      doing an unexec.  After unexec the return value is undefined.
2150  *      See crt0.c for further explanation and _start.
2151  *
2152  */
2153
2154 #if !defined(HAVE_TEXT_START) && !defined(PDUMP)
2155
2156 #ifdef __cplusplus
2157   extern "C" int _start (void);
2158 #else
2159   extern int _start (void);
2160 #endif
2161
2162 char *
2163 start_of_text (void)
2164 {
2165 #ifdef TEXT_START
2166   return ((char *) TEXT_START);
2167 #else
2168 #ifdef GOULD
2169   extern csrt ();
2170   return ((char *) csrt);
2171 #else /* not GOULD */
2172   return ((char *) _start);
2173 #endif /* GOULD */
2174 #endif /* TEXT_START */
2175 }
2176 #endif /* !defined(HAVE_TEXT_START) && !defined(PDUMP) */
2177
2178 /*
2179  *      Return the address of the start of the data segment prior to
2180  *      doing an unexec.  After unexec the return value is undefined.
2181  *      See crt0.c for further information and definition of data_start.
2182  *
2183  *      Apparently, on BSD systems this is etext at startup.  On
2184  *      USG systems (swapping) this is highly mmu dependent and
2185  *      is also dependent on whether or not the program is running
2186  *      with shared text.  Generally there is a (possibly large)
2187  *      gap between end of text and start of data with shared text.
2188  *
2189  *      On Uniplus+ systems with shared text, data starts at a
2190  *      fixed address.  Each port (from a given oem) is generally
2191  *      different, and the specific value of the start of data can
2192  *      be obtained via the UniPlus+ specific "uvar" system call,
2193  *      however the method outlined in crt0.c seems to be more portable.
2194  *
2195  *      Probably what will have to happen when a USG unexec is available,
2196  *      at least on UniPlus, is temacs will have to be made unshared so
2197  *      that text and data are contiguous.  Then once loadup is complete,
2198  *      unexec will produce a shared executable where the data can be
2199  *      at the normal shared text boundary and the startofdata variable
2200  *      will be patched by unexec to the correct value.
2201  *
2202  */
2203
2204 #if defined(ORDINARY_LINK) && !defined(__MINGW32__)
2205 extern char **environ;
2206 #endif
2207
2208 void *
2209 start_of_data (void)
2210 {
2211 #ifdef DATA_START
2212   return ((char *) DATA_START);
2213 #else
2214 #ifdef ORDINARY_LINK
2215   /*
2216    * This is a hack.  Since we're not linking crt0.c or pre_crt0.c,
2217    * data_start isn't defined.  We take the address of environ, which
2218    * is known to live at or near the start of the system crt0.c, and
2219    * we don't sweat the handful of bytes that might lose.
2220    */
2221 #if defined (HEAP_IN_DATA) && !defined(PDUMP)
2222   extern char* static_heap_base;
2223   if (!initialized)
2224     return static_heap_base;
2225 #endif
2226   return((char *) &environ);
2227 #else
2228   extern int data_start;
2229   return ((char *) &data_start);
2230 #endif /* ORDINARY_LINK */
2231 #endif /* DATA_START */
2232 }
2233 #endif /* NEED_STARTS (not CANNOT_DUMP or not SYSTEM_MALLOC) */
2234
2235 #if !defined(CANNOT_DUMP) && !defined(PDUMP)
2236 /* Some systems that cannot dump also cannot implement these.  */
2237
2238 /*
2239  *      Return the address of the end of the text segment prior to
2240  *      doing an unexec.  After unexec the return value is undefined.
2241  */
2242
2243 char *
2244 end_of_text (void)
2245 {
2246 #ifdef TEXT_END
2247   return ((char *) TEXT_END);
2248 #else
2249   extern int etext;
2250   return ((char *) &etext);
2251 #endif
2252 }
2253
2254 /*
2255  *      Return the address of the end of the data segment prior to
2256  *      doing an unexec.  After unexec the return value is undefined.
2257  */
2258
2259 char *
2260 end_of_data (void)
2261 {
2262 #ifdef DATA_END
2263   return ((char *) DATA_END);
2264 #else
2265   extern int edata;
2266   return ((char *) &edata);
2267 #endif
2268 }
2269
2270 #endif /* !defined(CANNOT_DUMP) && !defined(PDUMP) */
2271
2272 \f
2273 /************************************************************************/
2274 /*                          get the system name                         */
2275 /************************************************************************/
2276
2277 /* init_system_name sets up the string for the Lisp function
2278    system-name to return. */
2279
2280 extern Lisp_Object Vsystem_name;
2281
2282 #ifdef HAVE_SOCKETS
2283 # include <sys/socket.h>
2284 # include <netdb.h>
2285 #endif /* HAVE_SOCKETS */
2286
2287 void
2288 init_system_name (void)
2289 {
2290 #if defined (WINDOWSNT)
2291   char hostname [MAX_COMPUTERNAME_LENGTH + 1];
2292   size_t size = sizeof (hostname);
2293   GetComputerName (hostname, &size);
2294   Vsystem_name = build_string (hostname);
2295 #elif !defined (HAVE_GETHOSTNAME)
2296   struct utsname uts;
2297   uname (&uts);
2298   Vsystem_name = build_string (uts.nodename);
2299 #else /* HAVE_GETHOSTNAME */
2300   unsigned int hostname_size = 256;
2301   char *hostname = (char *) alloca (hostname_size);
2302
2303   /* Try to get the host name; if the buffer is too short, try
2304      again.  Apparently, the only indication gethostname gives of
2305      whether the buffer was large enough is the presence or absence
2306      of a '\0' in the string.  Eech.  */
2307   for (;;)
2308     {
2309       gethostname (hostname, hostname_size - 1);
2310       hostname[hostname_size - 1] = '\0';
2311
2312       /* Was the buffer large enough for the '\0'?  */
2313       if (strlen (hostname) < (size_t) (hostname_size - 1))
2314         break;
2315
2316       hostname_size <<= 1;
2317       hostname = (char *) alloca (hostname_size);
2318     }
2319 # if defined( HAVE_SOCKETS) && !defined(BROKEN_CYGWIN)
2320   /* Turn the hostname into the official, fully-qualified hostname.
2321      Don't do this if we're going to dump; this can confuse system
2322      libraries on some machines and make the dumped emacs core dump. */
2323 #  ifndef CANNOT_DUMP
2324   if (initialized)
2325 #  endif /* not CANNOT_DUMP */
2326     if (!strchr (hostname, '.'))
2327       {
2328 #  if !(defined(HAVE_GETADDRINFO) && defined(HAVE_GETNAMEINFO))
2329         struct hostent *hp = NULL;
2330         int count;
2331 #   ifdef TRY_AGAIN
2332         for (count = 0; count < 10; count++)
2333           {
2334             h_errno = 0;
2335 #   endif
2336             /* Some systems can't handle SIGALARM/SIGIO in gethostbyname(). */
2337             stop_interrupts ();
2338             hp = gethostbyname (hostname);
2339             start_interrupts ();
2340 #   ifdef TRY_AGAIN
2341             if (! (hp == 0 && h_errno == TRY_AGAIN))
2342               break;
2343             Fsleep_for (make_int (1));
2344           }
2345 #   endif
2346         if (hp)
2347           {
2348             const char *fqdn = (const char *) hp->h_name;
2349
2350             if (!strchr (fqdn, '.'))
2351               {
2352                 /* We still don't have a fully qualified domain name.
2353                    Try to find one in the list of alternate names */
2354                 char **alias = hp->h_aliases;
2355                 while (*alias && !strchr (*alias, '.'))
2356                   alias++;
2357                 if (*alias)
2358                   fqdn = *alias;
2359               }
2360             hostname = (char *) alloca (strlen (fqdn) + 1);
2361             strcpy (hostname, fqdn);
2362           }
2363 #  else /* !(HAVE_GETADDRINFO && HAVE_GETNAMEINFO) */
2364         struct addrinfo hints, *res;
2365
2366         xzero (hints);
2367         hints.ai_flags = AI_CANONNAME;
2368         hints.ai_family = AF_UNSPEC;
2369         hints.ai_socktype = SOCK_STREAM;
2370         hints.ai_protocol = 0;
2371         if (!getaddrinfo (hostname, NULL, &hints, &res))
2372           {
2373             hostname = (char *) alloca (strlen (res->ai_canonname) + 1);
2374             strcpy (hostname, res->ai_canonname);
2375
2376             freeaddrinfo (res);
2377           }
2378 #  endif  /* !(HAVE_GETADDRINFO && HAVE_GETNAMEINFO) */
2379       }
2380 # endif /* HAVE_SOCKETS */
2381   Vsystem_name = build_string (hostname);
2382 #endif /* HAVE_GETHOSTNAME  */
2383   {
2384     Bufbyte *p;
2385     Bytecount i;
2386
2387     for (i = 0, p = XSTRING_DATA (Vsystem_name);
2388          i < XSTRING_LENGTH (Vsystem_name);
2389          i++, p++)
2390       {
2391         if (*p == ' ' || *p == '\t')
2392           *p = '-';
2393       }
2394   }
2395 }
2396
2397 \f
2398 /************************************************************************/
2399 /*                        Emulation of select()                         */
2400 /************************************************************************/
2401
2402 #ifndef HAVE_SELECT
2403
2404 ERROR: XEmacs requires a working select().
2405
2406 #endif /* not HAVE_SELECT */
2407
2408 \f
2409 /************************************************************************/
2410 /*                      Emulation of signal stuff                       */
2411 /************************************************************************/
2412
2413 /* BSD 4.1 crap deleted.  4.2 was released in 1983, for God's sake!  I
2414    can't imagine that anyone is actually running that OS any more.
2415    You can't use X under it (I think) because there's no select().
2416    Anyway, the signal stuff has all been changed.  If someone wants to
2417    get this stuff working again, look in the FSF Emacs sources. */
2418
2419 /* POSIX signals support - DJB */
2420
2421 #ifdef HAVE_SIGPROCMASK
2422
2423 /* #### Is there any reason this is static global rather than local? */
2424 static struct sigaction new_action, old_action;
2425
2426 signal_handler_t
2427 sys_do_signal (int signal_number, signal_handler_t action)
2428 {
2429 #if 0
2430
2431   /* XEmacs works better if system calls are *not* restarted.
2432      This allows C-g to interrupt reads and writes, on most systems.
2433
2434      #### Another possibility is to just longjmp() out of the signal
2435      handler.  According to W.R. Stevens, this should be OK on all
2436      systems.  However, I don't want to deal with the potential
2437      evil ramifications of this at this point. */
2438
2439 #ifdef DGUX
2440   /* This gets us restartable system calls for efficiency.
2441      The "else" code will work as well. */
2442   return (berk_signal (signal_number, action));
2443 #else
2444   sigemptyset (&new_action.sa_mask);
2445   new_action.sa_handler = action;
2446 #if defined (SA_RESTART)
2447   /* Emacs mostly works better with restartable system services. If this
2448    * flag exists, we probably want to turn it on here.
2449    */
2450   new_action.sa_flags = SA_RESTART;
2451 #else
2452   new_action.sa_flags = 0;
2453 #endif
2454   sigaction (signal_number, &new_action, &old_action);
2455   return (old_action.sa_handler);
2456 #endif /* DGUX */
2457
2458 #else /* not 0 */
2459
2460   sigemptyset (&new_action.sa_mask);
2461   new_action.sa_handler = action;
2462 #if defined (SA_INTERRUPT) /* don't restart system calls, under SunOS */
2463   new_action.sa_flags = SA_INTERRUPT;
2464 #else
2465   new_action.sa_flags = 0;
2466 #endif
2467   sigaction (signal_number, &new_action, &old_action);
2468   return (signal_handler_t) (old_action.sa_handler);
2469
2470 #endif /* not 0 */
2471 }
2472
2473 #elif defined (HAVE_SIGBLOCK)
2474
2475 /* We use sigvec() rather than signal() if we have it, because
2476    it lets us specify interruptible system calls. */
2477 signal_handler_t
2478 sys_do_signal (int signal_number, signal_handler_t action)
2479 {
2480   struct sigvec vec, ovec;
2481
2482   vec.sv_handler = action;
2483   vec.sv_mask = 0;
2484 #ifdef SV_INTERRUPT /* don't restart system calls */
2485   vec.sv_flags = SV_INTERRUPT;
2486 #else
2487   vec.sv_flags = 0;
2488 #endif
2489
2490   sigvec (signal_number, &vec, &ovec);
2491
2492   return (ovec.sv_handler);
2493 }
2494
2495 #endif /* HAVE_SIGBLOCK (HAVE_SIGPROCMASK) */
2496
2497 \f
2498 /************************************************************************/
2499 /*           Emulation of strerror() and errno support                  */
2500 /************************************************************************/
2501
2502 #ifndef HAVE_STRERROR
2503
2504 #if !defined(NeXT) && !defined(__alpha) && !defined(MACH) && !defined(LINUX) && !defined(IRIX) && !defined(__NetBSD__)
2505 /* Linux added here by Raymond L. Toy <toy@alydar.crd.ge.com> for XEmacs. */
2506 /* Irix added here by gparker@sni-usa.com for XEmacs. */
2507 /* NetBSD added here by James R Grinter <jrg@doc.ic.ac.uk> for XEmacs */
2508 extern const char *sys_errlist[];
2509 extern int sys_nerr;
2510 #endif
2511
2512 #ifdef __NetBSD__
2513 extern char *sys_errlist[];
2514 extern int sys_nerr;
2515 #endif
2516
2517
2518 const char *
2519 strerror (int errnum)
2520 {
2521   if (errnum >= 0 && errnum < sys_nerr)
2522     return sys_errlist[errnum];
2523   return ((const char *) GETTEXT ("Unknown error"));
2524 }
2525
2526 #endif /* ! HAVE_STRERROR */
2527
2528 #ifdef WINDOWSNT
2529
2530 struct errentry {
2531   unsigned long oscode;  /* Win32 error */
2532   int errnocode;         /* unix errno */
2533 };
2534
2535 static struct errentry errtable[] = {
2536   {  ERROR_INVALID_FUNCTION,       EINVAL    },  /* 1 */
2537   {  ERROR_FILE_NOT_FOUND,         ENOENT    },  /* 2 */
2538   {  ERROR_PATH_NOT_FOUND,         ENOENT    },  /* 3 */
2539   {  ERROR_TOO_MANY_OPEN_FILES,    EMFILE    },  /* 4 */
2540   {  ERROR_ACCESS_DENIED,          EACCES    },  /* 5 */
2541   {  ERROR_INVALID_HANDLE,         EBADF     },  /* 6 */
2542   {  ERROR_ARENA_TRASHED,          ENOMEM    },  /* 7 */
2543   {  ERROR_NOT_ENOUGH_MEMORY,      ENOMEM    },  /* 8 */
2544   {  ERROR_INVALID_BLOCK,          ENOMEM    },  /* 9 */
2545   {  ERROR_BAD_ENVIRONMENT,        E2BIG     },  /* 10 */
2546   {  ERROR_BAD_FORMAT,             ENOEXEC   },  /* 11 */
2547   {  ERROR_INVALID_ACCESS,         EINVAL    },  /* 12 */
2548   {  ERROR_INVALID_DATA,           EINVAL    },  /* 13 */
2549   {  ERROR_INVALID_DRIVE,          ENOENT    },  /* 15 */
2550   {  ERROR_CURRENT_DIRECTORY,      EACCES    },  /* 16 */
2551   {  ERROR_NOT_SAME_DEVICE,        EXDEV     },  /* 17 */
2552   {  ERROR_NO_MORE_FILES,          ENOENT    },  /* 18 */
2553   {  ERROR_LOCK_VIOLATION,         EACCES    },  /* 33 */
2554   {  ERROR_BAD_NETPATH,            ENOENT    },  /* 53 */
2555   {  ERROR_NETWORK_ACCESS_DENIED,  EACCES    },  /* 65 */
2556   {  ERROR_BAD_NET_NAME,           ENOENT    },  /* 67 */
2557   {  ERROR_FILE_EXISTS,            EEXIST    },  /* 80 */
2558   {  ERROR_CANNOT_MAKE,            EACCES    },  /* 82 */
2559   {  ERROR_FAIL_I24,               EACCES    },  /* 83 */
2560   {  ERROR_INVALID_PARAMETER,      EINVAL    },  /* 87 */
2561   {  ERROR_NO_PROC_SLOTS,          EAGAIN    },  /* 89 */
2562   {  ERROR_DRIVE_LOCKED,           EACCES    },  /* 108 */
2563   {  ERROR_BROKEN_PIPE,            EPIPE     },  /* 109 */
2564   {  ERROR_DISK_FULL,              ENOSPC    },  /* 112 */
2565   {  ERROR_INVALID_TARGET_HANDLE,  EBADF     },  /* 114 */
2566   {  ERROR_INVALID_HANDLE,         EINVAL    },  /* 124 */
2567   {  ERROR_WAIT_NO_CHILDREN,       ECHILD    },  /* 128 */
2568   {  ERROR_CHILD_NOT_COMPLETE,     ECHILD    },  /* 129 */
2569   {  ERROR_DIRECT_ACCESS_HANDLE,   EBADF     },  /* 130 */
2570   {  ERROR_NEGATIVE_SEEK,          EINVAL    },  /* 131 */
2571   {  ERROR_SEEK_ON_DEVICE,         EACCES    },  /* 132 */
2572   {  ERROR_DIR_NOT_EMPTY,          ENOTEMPTY },  /* 145 */
2573   {  ERROR_NOT_LOCKED,             EACCES    },  /* 158 */
2574   {  ERROR_BAD_PATHNAME,           ENOENT    },  /* 161 */
2575   {  ERROR_MAX_THRDS_REACHED,      EAGAIN    },  /* 164 */
2576   {  ERROR_LOCK_FAILED,            EACCES    },  /* 167 */
2577   {  ERROR_ALREADY_EXISTS,         EEXIST    },  /* 183 */
2578   {  ERROR_FILENAME_EXCED_RANGE,   ENOENT    },  /* 206 */
2579   {  ERROR_NESTING_NOT_ALLOWED,    EAGAIN    },  /* 215 */
2580   {  ERROR_NOT_ENOUGH_QUOTA,       ENOMEM    }    /* 1816 */
2581 };
2582
2583 /* The following two constants must be the minimum and maximum
2584    values in the (contiguous) range of Exec Failure errors. */
2585 #define MIN_EXEC_ERROR ERROR_INVALID_STARTING_CODESEG
2586 #define MAX_EXEC_ERROR ERROR_INFLOOP_IN_RELOC_CHAIN
2587
2588 /* These are the low and high value in the range of errors that are
2589    access violations */
2590 #define MIN_EACCES_RANGE ERROR_WRITE_PROTECT
2591 #define MAX_EACCES_RANGE ERROR_SHARING_BUFFER_EXCEEDED
2592
2593 void
2594 mswindows_set_errno (unsigned long win32_error)
2595 {
2596   int i;
2597
2598   /* check the table for the OS error code */
2599   for (i = 0; i < countof (errtable); ++i)
2600     {
2601       if (win32_error == errtable[i].oscode)
2602         {
2603           errno = errtable[i].errnocode;
2604           return;
2605         }
2606     }
2607
2608   /* The error code wasn't in the table.  We check for a range of
2609    * EACCES errors or exec failure errors (ENOEXEC).  Otherwise EINVAL is
2610    * returned. */
2611   if (win32_error >= MIN_EACCES_RANGE && win32_error <= MAX_EACCES_RANGE)
2612     errno = EACCES;
2613   else if (win32_error >= MIN_EXEC_ERROR && win32_error <= MAX_EXEC_ERROR)
2614     errno = ENOEXEC;
2615   else
2616     errno = EINVAL;
2617 }
2618
2619 void
2620 mswindows_set_last_errno (void)
2621 {
2622   mswindows_set_errno (GetLastError ());
2623 }
2624
2625 #endif /* WINDOWSNT */
2626
2627 \f
2628 /************************************************************************/
2629 /*                    Encapsulations of system calls                    */
2630 /************************************************************************/
2631
2632 #define PATHNAME_CONVERT_OUT(path) \
2633   TO_EXTERNAL_FORMAT (C_STRING, (path), C_STRING_ALLOCA, (path), Qfile_name);
2634
2635 /***************** low-level calls ****************/
2636
2637 /*
2638  *      On USG systems the system calls are INTERRUPTIBLE by signals
2639  *      that the user program has elected to catch.  Thus the system call
2640  *      must be retried in these cases.  To handle this without massive
2641  *      changes in the source code, we remap the standard system call names
2642  *      to names for our own functions in sysdep.c that do the system call
2643  *      with retries.  Actually, for portability reasons, it is good
2644  *      programming practice, as this example shows, to limit all actual
2645  *      system calls to a single occurrence in the source.  Sure, this
2646  *      adds an extra level of function call overhead but it is almost
2647  *      always negligible.   Fred Fish, Unisoft Systems Inc.
2648  */
2649
2650 /* Ben sez: read Dick Gabriel's essay about the Worse Is Better
2651    approach to programming and its connection to the silly
2652    interruptible-system-call business.  To find it, look on
2653    Jamie's home page (http://www.jwz.org/worse-is-better.html). */
2654
2655 #ifdef ENCAPSULATE_OPEN
2656 int
2657 sys_open (const char *path, int oflag, ...)
2658 {
2659   int mode;
2660   va_list ap;
2661
2662   va_start (ap, oflag);
2663   mode = va_arg (ap, int);
2664   va_end (ap);
2665
2666   PATHNAME_CONVERT_OUT (path);
2667
2668 #ifdef WINDOWSNT
2669   /* Make all handles non-inheritable */
2670   oflag |= _O_NOINHERIT;
2671 #endif
2672
2673 #ifdef INTERRUPTIBLE_OPEN
2674   {
2675     int rtnval;
2676     while ((rtnval = open (path, oflag, mode)) == -1
2677            && (errno == EINTR))
2678       DO_NOTHING;
2679     return rtnval;
2680   }
2681 #else
2682   return open (path, oflag, mode);
2683 #endif
2684 }
2685 #endif /* ENCAPSULATE_OPEN */
2686
2687 /* Like sys_open, only when open() is interrupted by EINTR, check for
2688    QUIT.  This allows the callers of this function to be interrupted
2689    with C-g when, say, reading from named pipes.  However, this should
2690    be used with caution, as it can GC.
2691
2692    This function will not function as expected on systems where open()
2693    is not interrupted by C-g.  However, the worst that can happen is
2694    the fallback to simple open().  */
2695 int
2696 interruptible_open (const char *path, int oflag, int mode)
2697 {
2698   /* This function can GC */
2699   size_t len = strlen (path);
2700   char *nonreloc = (char *) alloca (len + 1);
2701
2702   /* Must copy PATH, because it might be the data of a Lisp_String,
2703      which could be relocated by GC when checking for QUIT.  */
2704   memcpy (nonreloc, path, len + 1);
2705
2706   PATHNAME_CONVERT_OUT (nonreloc);
2707
2708 #ifdef WINDOWSNT
2709   /* Make all handles non-inheritable */
2710   oflag |= _O_NOINHERIT;
2711 #endif
2712
2713   for (;;)
2714     {
2715       int rtnval = open (nonreloc, oflag, mode);
2716       if (!(rtnval == -1 && errno == EINTR))
2717         return rtnval;
2718       /* open() was interrupted.  Was QUIT responsible?  */
2719       QUIT;
2720     }
2721 }
2722
2723 #ifdef ENCAPSULATE_CLOSE
2724 int
2725 sys_close (int filedes)
2726 {
2727 #ifdef INTERRUPTIBLE_CLOSE
2728   int did_retry = 0;
2729   REGISTER int rtnval;
2730
2731   while ((rtnval = close (filedes)) == -1
2732          && (errno == EINTR))
2733     did_retry = 1;
2734
2735   /* If close is interrupted SunOS 4.1 may or may not have closed the
2736      file descriptor.  If it did the second close will fail with
2737      errno = EBADF.  That means we have succeeded.  */
2738   if (rtnval == -1 && did_retry && errno == EBADF)
2739     return 0;
2740
2741   return rtnval;
2742 #else
2743   return close (filedes);
2744 #endif
2745 }
2746 #endif /* ENCAPSULATE_CLOSE */
2747
2748 ssize_t
2749 sys_read_1 (int fildes, void *buf, size_t nbyte, int allow_quit)
2750 {
2751   ssize_t rtnval;
2752
2753   /* No harm in looping regardless of the INTERRUPTIBLE_IO setting. */
2754   while ((rtnval = read (fildes, buf, nbyte)) == -1
2755          && (errno == EINTR))
2756     {
2757       if (allow_quit)
2758         REALLY_QUIT;
2759     }
2760   return rtnval;
2761 }
2762
2763 #ifdef ENCAPSULATE_READ
2764 ssize_t
2765 sys_read (int fildes, void *buf, size_t nbyte)
2766 {
2767   return sys_read_1 (fildes, buf, nbyte, 0);
2768 }
2769 #endif /* ENCAPSULATE_READ */
2770
2771 ssize_t
2772 sys_write_1 (int fildes, const void *buf, size_t nbyte, int allow_quit)
2773 {
2774   ssize_t bytes_written = 0;
2775   const char *b = (const char *) buf;
2776
2777   /* No harm in looping regardless of the INTERRUPTIBLE_IO setting. */
2778   while (nbyte > 0)
2779     {
2780       ssize_t rtnval = write (fildes, b, nbyte);
2781
2782       if (allow_quit)
2783         REALLY_QUIT;
2784
2785       if (rtnval == -1)
2786         {
2787           if (errno == EINTR)
2788             continue;
2789           else
2790             return bytes_written ? bytes_written : -1;
2791         }
2792       b += rtnval;
2793       nbyte -= rtnval;
2794       bytes_written += rtnval;
2795     }
2796   return bytes_written;
2797 }
2798
2799 #ifdef ENCAPSULATE_WRITE
2800 ssize_t
2801 sys_write (int fildes, const void *buf, size_t nbyte)
2802 {
2803   return sys_write_1 (fildes, buf, nbyte, 0);
2804 }
2805 #endif /* ENCAPSULATE_WRITE */
2806
2807
2808 /**************** stdio calls ****************/
2809
2810 /* There is at least some evidence that the stdio calls are interruptible
2811    just like the normal system calls, at least on some systems.  In any
2812    case, it doesn't hurt to encapsulate them. */
2813
2814 /* #### Should also encapsulate fflush().
2815    #### Should conceivably encapsulate getchar() etc.  What a pain! */
2816
2817 #ifdef ENCAPSULATE_FOPEN
2818 FILE *
2819 sys_fopen (const char *path, const char *type)
2820 {
2821   PATHNAME_CONVERT_OUT (path);
2822 #if defined (WINDOWSNT)
2823   {
2824     int fd;
2825     int oflag;
2826     const char * type_save = type;
2827
2828     /* Force all file handles to be non-inheritable.  This is necessary to
2829        ensure child processes don't unwittingly inherit handles that might
2830        prevent future file access. */
2831
2832     if (type[0] == 'r')
2833       oflag = O_RDONLY;
2834     else if (type[0] == 'w' || type[0] == 'a')
2835       oflag = O_WRONLY | O_CREAT | O_TRUNC;
2836     else
2837       return 0;
2838
2839     /* Only do simplistic option parsing. */
2840     while (*++type)
2841       if (type[0] == '+')
2842         {
2843           oflag &= ~(O_RDONLY | O_WRONLY);
2844           oflag |= O_RDWR;
2845         }
2846       else if (type[0] == 'b')
2847         {
2848           oflag &= ~O_TEXT;
2849           oflag |= O_BINARY;
2850         }
2851       else if (type[0] == 't')
2852         {
2853           oflag &= ~O_BINARY;
2854           oflag |= O_TEXT;
2855         }
2856       else break;
2857
2858     fd = open (path, oflag | _O_NOINHERIT, 0644);
2859     if (fd < 0)
2860       return NULL;
2861
2862     return _fdopen (fd, type_save);
2863   }
2864 #elif defined (INTERRUPTIBLE_OPEN)
2865   {
2866     FILE *rtnval;
2867     while (!(rtnval = fopen (path, type)) && (errno == EINTR))
2868       DO_NOTHING;
2869     return rtnval;
2870   }
2871 #else
2872   return fopen (path, type);
2873 #endif
2874 }
2875 #endif /* ENCAPSULATE_FOPEN */
2876
2877
2878 #ifdef ENCAPSULATE_FCLOSE
2879 int
2880 sys_fclose (FILE *stream)
2881 {
2882 #ifdef INTERRUPTIBLE_CLOSE
2883   int rtnval;
2884
2885   while ((rtnval = fclose (stream)) == EOF
2886          && (errno == EINTR))
2887     ;
2888   return rtnval;
2889 #else
2890   return fclose (stream);
2891 #endif
2892 }
2893 #endif /* ENCAPSULATE_FCLOSE */
2894
2895
2896 #ifdef ENCAPSULATE_FREAD
2897 size_t
2898 sys_fread (void *ptr, size_t size, size_t nitem, FILE *stream)
2899 {
2900 #ifdef INTERRUPTIBLE_IO
2901   size_t rtnval;
2902   size_t items_read = 0;
2903   char *b = (char *) ptr;
2904
2905   while (nitem > 0)
2906     {
2907       rtnval = fread (b, size, nitem, stream);
2908       if (rtnval == 0)
2909         {
2910           if (ferror (stream) && errno == EINTR)
2911             continue;
2912           else
2913             return items_read;
2914         }
2915       b += size*rtnval;
2916       nitem -= rtnval;
2917       items_read += rtnval;
2918     }
2919   return (items_read);
2920 #else
2921   return fread (ptr, size, nitem, stream);
2922 #endif
2923 }
2924 #endif /* ENCAPSULATE_FREAD */
2925
2926
2927 #ifdef ENCAPSULATE_FWRITE
2928 size_t
2929 sys_fwrite (const void *ptr, size_t size, size_t nitem, FILE *stream)
2930 {
2931 #ifdef INTERRUPTIBLE_IO
2932   size_t rtnval;
2933   size_t items_written = 0;
2934   const char *b = (const char *) ptr;
2935
2936   while (nitem > 0)
2937     {
2938       rtnval = fwrite (b, size, nitem, stream);
2939       if (rtnval == 0)
2940         {
2941           if (ferror (stream) && errno == EINTR)
2942             continue;
2943           else
2944             return items_written;
2945         }
2946       b += size*rtnval;
2947       nitem -= rtnval;
2948       items_written += rtnval;
2949     }
2950   return (items_written);
2951 #else
2952   return fwrite (ptr, size, nitem, stream);
2953 #endif
2954 }
2955 #endif /* ENCAPSULATE_FWRITE */
2956
2957
2958 /********************* directory calls *******************/
2959
2960 #ifdef ENCAPSULATE_CHDIR
2961 int
2962 sys_chdir (const char *path)
2963 {
2964   PATHNAME_CONVERT_OUT (path);
2965   return chdir (path);
2966 }
2967 #endif /* ENCAPSULATE_CHDIR */
2968
2969
2970 #ifdef ENCAPSULATE_MKDIR
2971 int
2972 sys_mkdir (const char *path, mode_t mode)
2973 {
2974   PATHNAME_CONVERT_OUT (path);
2975 #ifdef WINDOWSNT
2976   return mkdir (path);
2977 #else
2978   return mkdir (path, mode);
2979 #endif
2980 }
2981 #endif /* ENCAPSULATE_MKDIR */
2982
2983
2984 #ifdef ENCAPSULATE_OPENDIR
2985 DIR *
2986 sys_opendir (const char *filename)
2987 {
2988   DIR *rtnval;
2989   PATHNAME_CONVERT_OUT (filename);
2990
2991   while (!(rtnval = opendir (filename))
2992          && (errno == EINTR))
2993     ;
2994   return rtnval;
2995 }
2996 #endif /* ENCAPSULATE_OPENDIR */
2997
2998
2999 #ifdef ENCAPSULATE_READDIR
3000 DIRENTRY *
3001 sys_readdir (DIR *dirp)
3002 {
3003   DIRENTRY *rtnval;
3004
3005   /* Apparently setting errno is necessary on some systems?
3006      Maybe readdir() doesn't always set errno ?! */
3007   while (!(errno = 0, rtnval = readdir (dirp))
3008          && (errno == EINTR))
3009     ;
3010 #ifndef MULE
3011   return rtnval;
3012 #else /* MULE */
3013   if (rtnval == NULL)           /* End of directory */
3014     return NULL;
3015   {
3016     Extcount external_len;
3017     int ascii_filename_p = 1;
3018     const Extbyte * const external_name = (const Extbyte *) rtnval->d_name;
3019
3020     /* Optimize for the common all-ASCII case, computing len en passant */
3021     for (external_len = 0; external_name[external_len] ; external_len++)
3022       {
3023         if (!BYTE_ASCII_P (external_name[external_len]))
3024           ascii_filename_p = 0;
3025       }
3026     if (ascii_filename_p)
3027       return rtnval;
3028
3029     { /* Non-ASCII filename */
3030       static Bufbyte_dynarr *internal_DIRENTRY;
3031       const Bufbyte *internal_name;
3032       Bytecount internal_len;
3033       if (!internal_DIRENTRY)
3034         internal_DIRENTRY = Dynarr_new (Bufbyte);
3035       else
3036         Dynarr_reset (internal_DIRENTRY);
3037
3038       Dynarr_add_many (internal_DIRENTRY, (Bufbyte *) rtnval,
3039                        offsetof (DIRENTRY, d_name));
3040
3041       TO_INTERNAL_FORMAT (DATA, (external_name, external_len),
3042                           ALLOCA, (internal_name, internal_len),
3043                           Qfile_name);
3044
3045       Dynarr_add_many (internal_DIRENTRY, internal_name, internal_len);
3046       Dynarr_add (internal_DIRENTRY, 0); /* zero-terminate */
3047       return (DIRENTRY *) Dynarr_atp (internal_DIRENTRY, 0);
3048     }
3049   }
3050 #endif /* MULE */
3051 }
3052 #endif /* ENCAPSULATE_READDIR */
3053
3054
3055 #ifdef ENCAPSULATE_CLOSEDIR
3056 int
3057 sys_closedir (DIR *dirp)
3058 {
3059   int rtnval;
3060
3061   while ((rtnval = closedir (dirp)) == -1
3062          && (errno == EINTR))
3063     ;
3064   return rtnval;
3065 }
3066 #endif /* ENCAPSULATE_CLOSEDIR */
3067
3068
3069 #ifdef ENCAPSULATE_RMDIR
3070 int
3071 sys_rmdir (const char *path)
3072 {
3073   PATHNAME_CONVERT_OUT (path);
3074   return rmdir (path);
3075 }
3076 #endif /* ENCAPSULATE_RMDIR */
3077
3078
3079 /***************** file-information calls ******************/
3080
3081 #ifdef ENCAPSULATE_ACCESS
3082 int
3083 sys_access (const char *path, int mode)
3084 {
3085   PATHNAME_CONVERT_OUT (path);
3086   return access (path, mode);
3087 }
3088 #endif /* ENCAPSULATE_ACCESS */
3089
3090
3091 #ifdef HAVE_EACCESS
3092 #ifdef ENCAPSULATE_EACCESS
3093 int
3094 sys_eaccess (const char *path, int mode)
3095 {
3096   PATHNAME_CONVERT_OUT (path);
3097   return eaccess (path, mode);
3098 }
3099 #endif /* ENCAPSULATE_EACCESS */
3100 #endif /* HAVE_EACCESS */
3101
3102
3103 #ifdef ENCAPSULATE_LSTAT
3104 int
3105 sys_lstat (const char *path, struct stat *buf)
3106 {
3107   PATHNAME_CONVERT_OUT (path);
3108   return lstat (path, buf);
3109 }
3110 #endif /* ENCAPSULATE_LSTAT */
3111
3112
3113 #ifdef ENCAPSULATE_READLINK
3114 int
3115 sys_readlink (const char *path, char *buf, size_t bufsiz)
3116 {
3117   PATHNAME_CONVERT_OUT (path);
3118   /* #### currently we don't do conversions on the incoming data */
3119   return readlink (path, buf, bufsiz);
3120 }
3121 #endif /* ENCAPSULATE_READLINK */
3122
3123
3124 #ifdef ENCAPSULATE_FSTAT
3125 int
3126 sys_fstat (int fd, struct stat *buf)
3127 {
3128   return fstat (fd, buf);
3129 }
3130 #endif /* ENCAPSULATE_FSTAT */
3131
3132
3133 #ifdef ENCAPSULATE_STAT
3134 int
3135 sys_stat (const char *path, struct stat *buf)
3136 {
3137   PATHNAME_CONVERT_OUT (path);
3138   return stat (path, buf);
3139 }
3140 #endif /* ENCAPSULATE_STAT */
3141
3142
3143 /****************** file-manipulation calls *****************/
3144
3145 #ifdef ENCAPSULATE_CHMOD
3146 int
3147 sys_chmod (const char *path, mode_t mode)
3148 {
3149   PATHNAME_CONVERT_OUT (path);
3150   return chmod (path, mode);
3151 }
3152 #endif /* ENCAPSULATE_CHMOD */
3153
3154
3155 #ifdef ENCAPSULATE_CREAT
3156 int
3157 sys_creat (const char *path, mode_t mode)
3158 {
3159   PATHNAME_CONVERT_OUT (path);
3160   return creat (path, mode);
3161 }
3162 #endif /* ENCAPSULATE_CREAT */
3163
3164
3165 #ifdef ENCAPSULATE_LINK
3166 int
3167 sys_link (const char *existing, const char *new)
3168 {
3169   PATHNAME_CONVERT_OUT (existing);
3170   PATHNAME_CONVERT_OUT (new);
3171   return link (existing, new);
3172 }
3173 #endif /* ENCAPSULATE_LINK */
3174
3175
3176 #ifdef ENCAPSULATE_RENAME
3177 int
3178 sys_rename (const char *old, const char *new)
3179 {
3180   PATHNAME_CONVERT_OUT (old);
3181   PATHNAME_CONVERT_OUT (new);
3182 #ifdef WINDOWSNT
3183   /* Windows rename fails if NEW exists */
3184   if (rename (old, new) == 0)
3185     return 0;
3186   if (errno != EEXIST)
3187     return -1;
3188   unlink (new);
3189 #endif /* WINDOWSNT */
3190   return rename (old, new);
3191 }
3192 #endif /* ENCAPSULATE_RENAME */
3193
3194
3195 #ifdef ENCAPSULATE_SYMLINK
3196 int
3197 sys_symlink (const char *name1, const char *name2)
3198 {
3199   PATHNAME_CONVERT_OUT (name1);
3200   PATHNAME_CONVERT_OUT (name2);
3201   return symlink (name1, name2);
3202 }
3203 #endif /* ENCAPSULATE_SYMLINK */
3204
3205
3206 #ifdef ENCAPSULATE_UNLINK
3207 int
3208 sys_unlink (const char *path)
3209 {
3210   PATHNAME_CONVERT_OUT (path);
3211   return unlink (path);
3212 }
3213 #endif /* ENCAPSULATE_UNLINK */
3214
3215
3216 #ifdef ENCAPSULATE_EXECVP
3217 int
3218 sys_execvp (const char *path, char * const * argv)
3219 {
3220   int i, argc;
3221   char ** new_argv;
3222
3223   PATHNAME_CONVERT_OUT (path);
3224   for (argc = 0; argv[argc]; argc++)
3225     ;
3226   new_argv = alloca_array (char *, argc + 1);
3227   for (i = 0; i < argc; i++)
3228     {
3229       new_argv[i] = argv[i];
3230       PATHNAME_CONVERT_OUT (new_argv[i]);
3231     }
3232   new_argv[argc] = NULL;
3233   return execvp (path, new_argv);
3234 }
3235 #endif /* ENCAPSULATE_EXECVP */
3236
3237 \f
3238 /************************************************************************/
3239 /*                  Emulations of missing system calls                  */
3240 /************************************************************************/
3241
3242 /***** (these are primarily required for USG, it seems) *****/
3243
3244 #ifndef HAVE_GETCWD
3245 char *
3246 getcwd (char *pathname, size_t size)
3247 {
3248   return getwd (pathname);
3249 }
3250 #endif /* emulate getcwd */
3251
3252
3253 #if 0 /* mrb */
3254 /*
3255  *      Warning, this function may not duplicate BSD 4.2 action properly
3256  *      under error conditions.
3257  */
3258
3259 #ifndef HAVE_GETWD
3260 char *
3261 getwd (char *pathname)
3262 {
3263   char *npath, *spath;
3264 #if !__STDC__ && !defined(STDC_HEADERS)
3265   extern char *getcwd ();
3266 #endif
3267
3268   spath = npath = getcwd ((char *) 0, MAXPATHLEN);
3269   if (spath == 0)
3270     return spath;
3271   /* On Altos 3068, getcwd can return @hostname/dir, so discard
3272      up to first slash.  Should be harmless on other systems.  */
3273   while (*npath && *npath != '/')
3274     npath++;
3275   strcpy (pathname, npath);
3276   xfree (spath);                  /* getcwd uses malloc */
3277   return pathname;
3278 }
3279 #endif /* HAVE_GETWD */
3280 #endif /* 0 - mrb */
3281
3282 /*
3283  *      Emulate rename using unlink/link.  Note that this is
3284  *      only partially correct.  Also, doesn't enforce restriction
3285  *      that files be of same type (regular->regular, dir->dir, etc).
3286  */
3287
3288 #ifndef HAVE_RENAME
3289 int
3290 rename (const char *from, const char *to)
3291 {
3292   if (access (from, 0) == 0)
3293     {
3294       unlink (to);
3295       if (link (from, to) == 0)
3296         if (unlink (from) == 0)
3297           return (0);
3298     }
3299   return (-1);
3300 }
3301 #endif /* HAVE_RENAME */
3302
3303 #ifdef HPUX
3304 #ifndef HAVE_PERROR
3305
3306 /* HPUX curses library references perror, but as far as we know
3307    it won't be called.  Anyway this definition will do for now.  */
3308
3309 perror (void)
3310 {
3311 }
3312
3313 #endif /* not HAVE_PERROR */
3314 #endif /* HPUX */
3315
3316 #ifndef HAVE_DUP2
3317
3318 /*
3319  *      Emulate BSD dup2.  First close newd if it already exists.
3320  *      Then, attempt to dup oldd.  If not successful, call dup2 recursively
3321  *      until we are, then close the unsuccessful ones.
3322  */
3323
3324 int
3325 dup2 (int oldd, int newd)
3326 {
3327   int fd, ret;
3328
3329   sys_close (newd);
3330
3331 #ifdef F_DUPFD
3332   fd = fcntl (oldd, F_DUPFD, newd);
3333   if (fd != newd)
3334     error ("can't dup2 (%i,%i) : %s", oldd, newd, strerror (errno));
3335 #else
3336   fd = dup (old);
3337   if (fd == -1)
3338     return -1;
3339   if (fd == new)
3340     return new;
3341   ret = dup2 (old, new);
3342   sys_close (fd);
3343   return ret;
3344 #endif /*  F_DUPFD */
3345 }
3346
3347 #endif /* not HAVE_DUP2 */
3348
3349 /*
3350  *      Gettimeofday.  Simulate as much as possible.  Only accurate
3351  *      to nearest second.  Emacs doesn't use tzp so ignore it for now.
3352  */
3353
3354 #if !defined (HAVE_GETTIMEOFDAY)
3355
3356 int
3357 gettimeofday (struct timeval *tp, struct timezone *tzp)
3358 {
3359   extern long time ();
3360
3361   tp->tv_sec = time ((long *)0);
3362   tp->tv_usec = 0;
3363   if (tzp != 0)
3364     tzp->tz_minuteswest = -1;
3365   return (0);
3366 }
3367
3368 #endif /* !HAVE_GETTIMEOFDAY */
3369
3370 /* No need to encapsulate utime and utimes explicitly because all
3371    access to those functions goes through the following. */
3372
3373 int
3374 set_file_times (char *filename, EMACS_TIME atime, EMACS_TIME mtime)
3375 {
3376 #ifdef HAVE_UTIMES
3377   struct timeval tv[2];
3378   tv[0] = atime;
3379   tv[1] = mtime;
3380   return utimes (filename, tv);
3381 #else /* not HAVE_UTIMES */
3382   struct utimbuf utb;
3383   utb.actime = EMACS_SECS (atime);
3384   utb.modtime = EMACS_SECS (mtime);
3385   return utime (filename, &utb);
3386 #endif /* not HAVE_UTIMES */
3387 }
3388
3389 /* */
3390
3391 static long ticks_per_second;
3392 static long orig_user_ticks, orig_system_ticks;
3393 EMACS_TIME orig_real_time;
3394
3395 static int process_times_available;
3396
3397 /* Return the relative user and system tick count.  We try to
3398    maintain calculations in terms of integers as long as possible
3399    for increased accuracy. */
3400
3401 static int
3402 get_process_times_1 (long *user_ticks, long *system_ticks)
3403 {
3404 #if defined (_SC_CLK_TCK) || defined (CLK_TCK) && !defined(WINDOWSNT)
3405   /* We have the POSIX times() function available. */
3406   struct tms tttt;
3407   times (&tttt);
3408   *user_ticks = (long) tttt.tms_utime;
3409   *system_ticks = (long) tttt.tms_stime;
3410   return 1;
3411 #elif defined (CLOCKS_PER_SEC)
3412   *user_ticks = (long) clock ();
3413   *system_ticks = 0;
3414   return 1;
3415 #else
3416   return 0;
3417 #endif
3418 }
3419
3420 void
3421 init_process_times_very_early (void)
3422 {
3423 #if defined (_SC_CLK_TCK)
3424   ticks_per_second = sysconf (_SC_CLK_TCK);
3425 #elif defined (CLK_TCK)
3426   ticks_per_second = CLK_TCK;
3427 #elif defined (CLOCKS_PER_SEC)
3428   ticks_per_second = CLOCKS_PER_SEC;
3429 #endif
3430
3431   process_times_available = get_process_times_1 (&orig_user_ticks,
3432                                                  &orig_system_ticks);
3433   EMACS_GET_TIME (orig_real_time);
3434 }
3435
3436 /* Return the user and system times used up by this process so far. */
3437 void
3438 get_process_times (double *user_time, double *system_time, double *real_time)
3439 {
3440   EMACS_TIME curr_real_time;
3441   EMACS_TIME elapsed_time;
3442   long curr_user_ticks, curr_system_ticks;
3443
3444   EMACS_GET_TIME (curr_real_time);
3445   EMACS_SUB_TIME (elapsed_time, curr_real_time, orig_real_time);
3446   *real_time = (EMACS_SECS (elapsed_time)
3447                 + ((double) EMACS_USECS (elapsed_time)) / 1000000);
3448   if (get_process_times_1 (&curr_user_ticks, &curr_system_ticks))
3449     {
3450       *user_time = (((double) (curr_user_ticks - orig_user_ticks))
3451                     / ticks_per_second);
3452       *system_time = (((double) (curr_system_ticks - orig_system_ticks))
3453                       / ticks_per_second);
3454     }
3455   else
3456     {
3457       /* A lame OS */
3458       *user_time = *real_time;
3459       *system_time = 0;
3460     }
3461 }
3462
3463 #ifndef HAVE_RANDOM
3464 #ifdef random
3465 #define HAVE_RANDOM
3466 #endif
3467 #endif
3468
3469 /* Figure out how many bits the system's random number generator uses.
3470    `random' and `lrand48' are assumed to return 31 usable bits.
3471    BSD `rand' returns a 31 bit value but the low order bits are unusable;
3472    so we'll shift it and treat it like the 15-bit USG `rand'.  */
3473
3474 #ifndef RAND_BITS
3475 # ifdef HAVE_RANDOM
3476 #  define RAND_BITS 31
3477 # else /* !HAVE_RANDOM */
3478 #  ifdef HAVE_LRAND48
3479 #   define RAND_BITS 31
3480 #   define random lrand48
3481 #  else /* !HAVE_LRAND48 */
3482 #   define RAND_BITS 15
3483 #   if RAND_MAX == 32767
3484 #    define random rand
3485 #   else /* RAND_MAX != 32767 */
3486 #    if RAND_MAX == 2147483647
3487 #     define random() (rand () >> 16)
3488 #    else /* RAND_MAX != 2147483647 */
3489 #     ifdef USG
3490 #      define random rand
3491 #     else
3492 #      define random() (rand () >> 16)
3493 #     endif /* !BSD */
3494 #    endif /* RAND_MAX != 2147483647 */
3495 #   endif /* RAND_MAX != 32767 */
3496 #  endif /* !HAVE_LRAND48 */
3497 # endif /* !HAVE_RANDOM */
3498 #endif /* !RAND_BITS */
3499
3500 void seed_random (long arg);
3501 void
3502 seed_random (long arg)
3503 {
3504 #ifdef HAVE_RANDOM
3505   srandom ((unsigned int)arg);
3506 #else
3507 # ifdef HAVE_LRAND48
3508   srand48 (arg);
3509 # else
3510   srand ((unsigned int)arg);
3511 # endif
3512 #endif
3513 }
3514
3515 /*
3516  * Build a full Emacs-sized word out of whatever we've got.
3517  * This suffices even for a 64-bit architecture with a 15-bit rand.
3518  */
3519 long get_random (void);
3520 long
3521 get_random (void)
3522 {
3523   long val = random ();
3524 #if VALBITS > RAND_BITS
3525   val = (val << RAND_BITS) ^ random ();
3526 #if VALBITS > 2*RAND_BITS
3527   val = (val << RAND_BITS) ^ random ();
3528 #if VALBITS > 3*RAND_BITS
3529   val = (val << RAND_BITS) ^ random ();
3530 #if VALBITS > 4*RAND_BITS
3531   val = (val << RAND_BITS) ^ random ();
3532 #endif /* need at least 5 */
3533 #endif /* need at least 4 */
3534 #endif /* need at least 3 */
3535 #endif /* need at least 2 */
3536   return val & ((1L << VALBITS) - 1);
3537 }
3538
3539 \f
3540 /************************************************************************/
3541 /*               Strings corresponding to defined signals               */
3542 /************************************************************************/
3543
3544 #if !defined (SYS_SIGLIST_DECLARED) && !defined (HAVE_SYS_SIGLIST)
3545
3546 #if defined(WINDOWSNT) || defined(__CYGWIN32__)
3547 const char *sys_siglist[] =
3548   {
3549     "bum signal!!",
3550     "hangup",
3551     "interrupt",
3552     "quit",
3553     "illegal instruction",
3554     "trace trap",
3555     "iot instruction",
3556     "emt instruction",
3557     "floating point exception",
3558     "kill",
3559     "bus error",
3560     "segmentation violation",
3561     "bad argument to system call",
3562     "write on a pipe with no one to read it",
3563     "alarm clock",
3564     "software termination signal from kill",
3565     "status signal",
3566     "sendable stop signal not from tty",
3567     "stop signal from tty",
3568     "continue a stopped process",
3569     "child status has changed",
3570     "background read attempted from control tty",
3571     "background write attempted from control tty",
3572     "input record available at control tty",
3573     "exceeded CPU time limit",
3574     "exceeded file size limit"
3575     };
3576 #endif
3577
3578 #ifdef USG
3579 #ifdef AIX
3580 const char *sys_siglist[NSIG + 1] =
3581   {
3582     /* AIX has changed the signals a bit */
3583     DEFER_GETTEXT ("bogus signal"),                     /* 0 */
3584     DEFER_GETTEXT ("hangup"),                           /* 1  SIGHUP */
3585     DEFER_GETTEXT ("interrupt"),                        /* 2  SIGINT */
3586     DEFER_GETTEXT ("quit"),                             /* 3  SIGQUIT */
3587     DEFER_GETTEXT ("illegal instruction"),              /* 4  SIGILL */
3588     DEFER_GETTEXT ("trace trap"),                       /* 5  SIGTRAP */
3589     DEFER_GETTEXT ("IOT instruction"),                  /* 6  SIGIOT */
3590     DEFER_GETTEXT ("crash likely"),                     /* 7  SIGDANGER */
3591     DEFER_GETTEXT ("floating point exception"),         /* 8  SIGFPE */
3592     DEFER_GETTEXT ("kill"),                             /* 9  SIGKILL */
3593     DEFER_GETTEXT ("bus error"),                        /* 10 SIGBUS */
3594     DEFER_GETTEXT ("segmentation violation"),           /* 11 SIGSEGV */
3595     DEFER_GETTEXT ("bad argument to system call"),      /* 12 SIGSYS */
3596     DEFER_GETTEXT ("write on a pipe with no one to read it"), /* 13 SIGPIPE */
3597     DEFER_GETTEXT ("alarm clock"),                      /* 14 SIGALRM */
3598     DEFER_GETTEXT ("software termination signum"),      /* 15 SIGTERM */
3599     DEFER_GETTEXT ("user defined signal 1"),            /* 16 SIGUSR1 */
3600     DEFER_GETTEXT ("user defined signal 2"),            /* 17 SIGUSR2 */
3601     DEFER_GETTEXT ("death of a child"),                 /* 18 SIGCLD */
3602     DEFER_GETTEXT ("power-fail restart"),               /* 19 SIGPWR */
3603     DEFER_GETTEXT ("bogus signal"),                     /* 20 */
3604     DEFER_GETTEXT ("bogus signal"),                     /* 21 */
3605     DEFER_GETTEXT ("bogus signal"),                     /* 22 */
3606     DEFER_GETTEXT ("bogus signal"),                     /* 23 */
3607     DEFER_GETTEXT ("bogus signal"),                     /* 24 */
3608     DEFER_GETTEXT ("LAN I/O interrupt"),                /* 25 SIGAIO */
3609     DEFER_GETTEXT ("PTY I/O interrupt"),                /* 26 SIGPTY */
3610     DEFER_GETTEXT ("I/O intervention required"),        /* 27 SIGIOINT */
3611 #ifdef AIXHFT
3612     DEFER_GETTEXT ("HFT grant"),                        /* 28 SIGGRANT */
3613     DEFER_GETTEXT ("HFT retract"),                      /* 29 SIGRETRACT */
3614     DEFER_GETTEXT ("HFT sound done"),                   /* 30 SIGSOUND */
3615     DEFER_GETTEXT ("HFT input ready"),                  /* 31 SIGMSG */
3616 #endif
3617     0
3618   };
3619 #else /* USG, not AIX */
3620 const char *sys_siglist[NSIG + 1] =
3621   {
3622     DEFER_GETTEXT ("bogus signal"),                     /* 0 */
3623     DEFER_GETTEXT ("hangup"),                           /* 1  SIGHUP */
3624     DEFER_GETTEXT ("interrupt"),                        /* 2  SIGINT */
3625     DEFER_GETTEXT ("quit"),                             /* 3  SIGQUIT */
3626     DEFER_GETTEXT ("illegal instruction"),              /* 4  SIGILL */
3627     DEFER_GETTEXT ("trace trap"),                       /* 5  SIGTRAP */
3628     DEFER_GETTEXT ("IOT instruction"),                  /* 6  SIGIOT */
3629     DEFER_GETTEXT ("EMT instruction"),                  /* 7  SIGEMT */
3630     DEFER_GETTEXT ("floating point exception"),         /* 8  SIGFPE */
3631     DEFER_GETTEXT ("kill"),                             /* 9  SIGKILL */
3632     DEFER_GETTEXT ("bus error"),                        /* 10 SIGBUS */
3633     DEFER_GETTEXT ("segmentation violation"),           /* 11 SIGSEGV */
3634     DEFER_GETTEXT ("bad argument to system call"),      /* 12 SIGSYS */
3635     DEFER_GETTEXT ("write on a pipe with no one to read it"), /* 13 SIGPIPE */
3636     DEFER_GETTEXT ("alarm clock"),                      /* 14 SIGALRM */
3637     DEFER_GETTEXT ("software termination signum"),      /* 15 SIGTERM */
3638     DEFER_GETTEXT ("user defined signal 1"),            /* 16 SIGUSR1 */
3639     DEFER_GETTEXT ("user defined signal 2"),            /* 17 SIGUSR2 */
3640     DEFER_GETTEXT ("death of a child"),                 /* 18 SIGCLD */
3641     DEFER_GETTEXT ("power-fail restart"),               /* 19 SIGPWR */
3642 #ifdef sun
3643     DEFER_GETTEXT ("window size changed"),              /* 20 SIGWINCH */
3644     DEFER_GETTEXT ("urgent socket condition"),          /* 21 SIGURG */
3645     DEFER_GETTEXT ("pollable event occurred"),          /* 22 SIGPOLL */
3646     DEFER_GETTEXT ("stop (cannot be caught or ignored)"), /*  23 SIGSTOP */
3647     DEFER_GETTEXT ("user stop requested from tty"),     /* 24 SIGTSTP */
3648     DEFER_GETTEXT ("stopped process has been continued"), /* 25 SIGCONT */
3649     DEFER_GETTEXT ("background tty read attempted"),    /* 26 SIGTTIN */
3650     DEFER_GETTEXT ("background tty write attempted"),   /* 27 SIGTTOU */
3651     DEFER_GETTEXT ("virtual timer expired"),            /* 28 SIGVTALRM */
3652     DEFER_GETTEXT ("profiling timer expired"),          /* 29 SIGPROF */
3653     DEFER_GETTEXT ("exceeded cpu limit"),               /* 30 SIGXCPU */
3654     DEFER_GETTEXT ("exceeded file size limit"),         /* 31 SIGXFSZ */
3655     DEFER_GETTEXT ("process's lwps are blocked"),       /* 32 SIGWAITING */
3656     DEFER_GETTEXT ("special signal used by thread library"), /* 33 SIGLWP */
3657 #ifdef SIGFREEZE
3658     DEFER_GETTEXT ("special signal used by CPR"),        /* 34 SIGFREEZE */
3659 #endif
3660 #ifdef SIGTHAW
3661     DEFER_GETTEXT ("special signal used by CPR"),        /* 35 SIGTHAW */
3662 #endif
3663 #endif /* sun */
3664     0
3665   };
3666 #endif /* not AIX */
3667 #endif /* USG */
3668 #ifdef DGUX
3669 const char *sys_siglist[NSIG + 1] =
3670   {
3671     DEFER_GETTEXT ("null signal"),                       /*  0 SIGNULL   */
3672     DEFER_GETTEXT ("hangup"),                            /*  1 SIGHUP    */
3673     DEFER_GETTEXT ("interrupt"),                         /*  2 SIGINT    */
3674     DEFER_GETTEXT ("quit"),                              /*  3 SIGQUIT   */
3675     DEFER_GETTEXT ("illegal instruction"),               /*  4 SIGILL    */
3676     DEFER_GETTEXT ("trace trap"),                        /*  5 SIGTRAP   */
3677     DEFER_GETTEXT ("abort termination"),                 /*  6 SIGABRT   */
3678     DEFER_GETTEXT ("SIGEMT"),                            /*  7 SIGEMT    */
3679     DEFER_GETTEXT ("floating point exception"),          /*  8 SIGFPE    */
3680     DEFER_GETTEXT ("kill"),                              /*  9 SIGKILL   */
3681     DEFER_GETTEXT ("bus error"),                         /* 10 SIGBUS    */
3682     DEFER_GETTEXT ("segmentation violation"),            /* 11 SIGSEGV   */
3683     DEFER_GETTEXT ("bad argument to system call"),       /* 12 SIGSYS    */
3684     DEFER_GETTEXT ("write on a pipe with no reader"),    /* 13 SIGPIPE   */
3685     DEFER_GETTEXT ("alarm clock"),                       /* 14 SIGALRM   */
3686     DEFER_GETTEXT ("software termination signal"),       /* 15 SIGTERM   */
3687     DEFER_GETTEXT ("user defined signal 1"),             /* 16 SIGUSR1   */
3688     DEFER_GETTEXT ("user defined signal 2"),             /* 17 SIGUSR2   */
3689     DEFER_GETTEXT ("child stopped or terminated"),       /* 18 SIGCLD    */
3690     DEFER_GETTEXT ("power-fail restart"),                /* 19 SIGPWR    */
3691     DEFER_GETTEXT ("window size changed"),               /* 20 SIGWINCH  */
3692     DEFER_GETTEXT ("undefined"),                         /* 21           */
3693     DEFER_GETTEXT ("pollable event occurred"),           /* 22 SIGPOLL   */
3694     DEFER_GETTEXT ("sendable stop signal not from tty"), /* 23 SIGSTOP   */
3695     DEFER_GETTEXT ("stop signal from tty"),              /* 24 SIGSTP    */
3696     DEFER_GETTEXT ("continue a stopped process"),        /* 25 SIGCONT   */
3697     DEFER_GETTEXT ("attempted background tty read"),     /* 26 SIGTTIN   */
3698     DEFER_GETTEXT ("attempted background tty write"),    /* 27 SIGTTOU   */
3699     DEFER_GETTEXT ("undefined"),                         /* 28           */
3700     DEFER_GETTEXT ("undefined"),                         /* 29           */
3701     DEFER_GETTEXT ("undefined"),                         /* 30           */
3702     DEFER_GETTEXT ("undefined"),                         /* 31           */
3703     DEFER_GETTEXT ("undefined"),                         /* 32           */
3704     DEFER_GETTEXT ("socket (TCP/IP) urgent data arrival"), /* 33 SIGURG    */
3705     DEFER_GETTEXT ("I/O is possible"),                   /* 34 SIGIO     */
3706     DEFER_GETTEXT ("exceeded cpu time limit"),           /* 35 SIGXCPU   */
3707     DEFER_GETTEXT ("exceeded file size limit"),          /* 36 SIGXFSZ   */
3708     DEFER_GETTEXT ("virtual time alarm"),                /* 37 SIGVTALRM */
3709     DEFER_GETTEXT ("profiling time alarm"),              /* 38 SIGPROF   */
3710     DEFER_GETTEXT ("undefined"),                         /* 39           */
3711     DEFER_GETTEXT ("file record locks revoked"),         /* 40 SIGLOST   */
3712     DEFER_GETTEXT ("undefined"),                         /* 41           */
3713     DEFER_GETTEXT ("undefined"),                         /* 42           */
3714     DEFER_GETTEXT ("undefined"),                         /* 43           */
3715     DEFER_GETTEXT ("undefined"),                         /* 44           */
3716     DEFER_GETTEXT ("undefined"),                         /* 45           */
3717     DEFER_GETTEXT ("undefined"),                         /* 46           */
3718     DEFER_GETTEXT ("undefined"),                         /* 47           */
3719     DEFER_GETTEXT ("undefined"),                         /* 48           */
3720     DEFER_GETTEXT ("undefined"),                         /* 49           */
3721     DEFER_GETTEXT ("undefined"),                         /* 50           */
3722     DEFER_GETTEXT ("undefined"),                         /* 51           */
3723     DEFER_GETTEXT ("undefined"),                         /* 52           */
3724     DEFER_GETTEXT ("undefined"),                         /* 53           */
3725     DEFER_GETTEXT ("undefined"),                         /* 54           */
3726     DEFER_GETTEXT ("undefined"),                         /* 55           */
3727     DEFER_GETTEXT ("undefined"),                         /* 56           */
3728     DEFER_GETTEXT ("undefined"),                         /* 57           */
3729     DEFER_GETTEXT ("undefined"),                         /* 58           */
3730     DEFER_GETTEXT ("undefined"),                         /* 59           */
3731     DEFER_GETTEXT ("undefined"),                         /* 60           */
3732     DEFER_GETTEXT ("undefined"),                         /* 61           */
3733     DEFER_GETTEXT ("undefined"),                         /* 62           */
3734     DEFER_GETTEXT ("undefined"),                         /* 63           */
3735     DEFER_GETTEXT ("notification message in mess. queue"), /* 64 SIGDGNOTIFY */
3736     0
3737   };
3738 #endif /* DGUX */
3739
3740 #endif /* ! SYS_SIGLIST_DECLARED && ! HAVE_SYS_SIGLIST */
3741
3742 \f
3743 /************************************************************************/
3744 /*         Directory routines for systems that don't have them          */
3745 /************************************************************************/
3746
3747 #ifdef SYSV_SYSTEM_DIR
3748
3749 #include <dirent.h>
3750
3751 #if defined(BROKEN_CLOSEDIR) || !defined(HAVE_CLOSEDIR)
3752 int
3753 closedir (DIR *dirp)  /* stream from opendir */
3754 {
3755   int rtnval;
3756
3757   rtnval = sys_close (dirp->dd_fd);
3758
3759   /* Some systems (like Solaris) allocate the buffer and the DIR all
3760      in one block.  Why in the world are we freeing this ourselves
3761      anyway?  */
3762 #if ! (defined (sun) && defined (USG5_4))
3763   xfree ((char *) dirp->dd_buf); /* directory block defined in <dirent.h> */
3764 #endif
3765   xfree ((char *) dirp);
3766   return (rtnval);
3767 }
3768 #endif /* BROKEN_CLOSEDIR or not HAVE_CLOSEDIR */
3769 #endif /* SYSV_SYSTEM_DIR */
3770
3771 #ifdef NONSYSTEM_DIR_LIBRARY
3772
3773 DIR *
3774 opendir (const char *filename)  /* name of directory */
3775 {
3776   DIR *dirp;            /* -> malloc'ed storage */
3777   int fd;               /* file descriptor for read */
3778   struct stat sbuf;             /* result of fstat */
3779
3780   fd = sys_open (filename, O_RDONLY);
3781   if (fd < 0)
3782     return 0;
3783
3784   if (fstat (fd, &sbuf) < 0
3785       || (sbuf.st_mode & S_IFMT) != S_IFDIR
3786       || (dirp = (DIR *) malloc (sizeof (DIR))) == 0)
3787     {
3788       sys_close (fd);
3789       return 0;         /* bad luck today */
3790     }
3791
3792   dirp->dd_fd = fd;
3793   dirp->dd_loc = dirp->dd_size = 0;     /* refill needed */
3794
3795   return dirp;
3796 }
3797
3798 void
3799 closedir (DIR *dirp)            /* stream from opendir */
3800 {
3801   sys_close (dirp->dd_fd);
3802   xfree (dirp);
3803 }
3804
3805
3806 #define DIRSIZ  14
3807 struct olddir
3808   {
3809     ino_t od_ino;               /* inode */
3810     char od_name[DIRSIZ];       /* filename */
3811   };
3812
3813 static struct direct dir_static; /* simulated directory contents */
3814
3815 /* ARGUSED */
3816 struct direct *
3817 readdir (DIR *dirp)     /* stream from opendir */
3818 {
3819   struct olddir *dp;    /* -> directory data */
3820
3821   for (; ;)
3822     {
3823       if (dirp->dd_loc >= dirp->dd_size)
3824         dirp->dd_loc = dirp->dd_size = 0;
3825
3826       if (dirp->dd_size == 0    /* refill buffer */
3827           && (dirp->dd_size = sys_read (dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ)) <= 0)
3828         return 0;
3829
3830       dp = (struct olddir *) &dirp->dd_buf[dirp->dd_loc];
3831       dirp->dd_loc += sizeof (struct olddir);
3832
3833       if (dp->od_ino != 0)      /* not deleted entry */
3834         {
3835           dir_static.d_ino = dp->od_ino;
3836           strncpy (dir_static.d_name, dp->od_name, DIRSIZ);
3837           dir_static.d_name[DIRSIZ] = '\0';
3838           dir_static.d_namlen = strlen (dir_static.d_name);
3839           dir_static.d_reclen = sizeof (struct direct)
3840             - MAXNAMLEN + 3
3841               + dir_static.d_namlen - dir_static.d_namlen % 4;
3842           return &dir_static;   /* -> simulated structure */
3843         }
3844     }
3845 }
3846
3847
3848 #endif /* NONSYSTEM_DIR_LIBRARY */
3849
3850 \f
3851 /* mkdir and rmdir functions, for systems which don't have them.  */
3852
3853 #ifndef HAVE_MKDIR
3854 /*
3855  * Written by Robert Rother, Mariah Corporation, August 1985.
3856  *
3857  * If you want it, it's yours.  All I ask in return is that if you
3858  * figure out how to do this in a Bourne Shell script you send me
3859  * a copy.
3860  *                                      sdcsvax!rmr or rmr@uscd
3861  *
3862  * Severely hacked over by John Gilmore to make a 4.2BSD compatible
3863  * subroutine.  11Mar86; hoptoad!gnu
3864  *
3865  * Modified by rmtodd@uokmax 6-28-87 -- when making an already existing dir,
3866  * subroutine didn't return EEXIST.  It does now.
3867  */
3868
3869 /*
3870  * Make a directory.
3871  */
3872 #ifdef MKDIR_PROTOTYPE
3873 MKDIR_PROTOTYPE
3874 #else
3875 int
3876 mkdir (const char *dpath, int dmode)
3877 #endif
3878 {
3879   int cpid, status, fd;
3880   struct stat statbuf;
3881
3882   if (stat (dpath, &statbuf) == 0)
3883     {
3884       errno = EEXIST;           /* Stat worked, so it already exists */
3885       return -1;
3886     }
3887
3888   /* If stat fails for a reason other than non-existence, return error */
3889   if (errno != ENOENT)
3890     return -1;
3891
3892   synch_process_alive = 1;
3893   switch (cpid = fork ())
3894     {
3895
3896     case -1:                    /* Error in fork() */
3897       return -1;                /* Errno is set already */
3898
3899     case 0:                     /* Child process */
3900     {
3901       /*
3902        * Cheap hack to set mode of new directory.  Since this
3903        * child process is going away anyway, we zap its umask.
3904        * ####, this won't suffice to set SUID, SGID, etc. on this
3905        * directory.  Does anybody care?
3906        */
3907       status = umask (0);       /* Get current umask */
3908       status = umask (status | (0777 & ~dmode));        /* Set for mkdir */
3909       fd = sys_open ("/dev/null", O_RDWR);
3910       if (fd >= 0)
3911         {
3912           if (fd != STDIN_FILENO)  dup2 (fd, STDIN_FILENO);
3913           if (fd != STDOUT_FILENO) dup2 (fd, STDOUT_FILENO);
3914           if (fd != STDERR_FILENO) dup2 (fd, STDERR_FILENO);
3915         }
3916       execl ("/bin/mkdir", "mkdir", dpath, (char *) 0);
3917       _exit (-1);               /* Can't exec /bin/mkdir */
3918     }
3919
3920     default:                    /* Parent process */
3921       wait_for_termination (cpid);
3922     }
3923
3924   if (synch_process_death != 0 || synch_process_retcode != 0)
3925     {
3926       errno = EIO;              /* We don't know why, but */
3927       return -1;                /* /bin/mkdir failed */
3928     }
3929
3930   return 0;
3931 }
3932 #endif /* not HAVE_MKDIR */
3933
3934 #ifndef HAVE_RMDIR
3935 int
3936 rmdir (const char *dpath)
3937 {
3938   int cpid, status, fd;
3939   struct stat statbuf;
3940
3941   if (stat (dpath, &statbuf) != 0)
3942     {
3943       /* Stat just set errno.  We don't have to */
3944       return -1;
3945     }
3946
3947   synch_process_alive = 1;
3948   switch (cpid = fork ())
3949     {
3950
3951     case -1:                    /* Error in fork() */
3952       return (-1);              /* Errno is set already */
3953
3954     case 0:                     /* Child process */
3955       fd = sys_open("/dev/null", O_RDWR);
3956       if (fd >= 0)
3957         {
3958           if (fd != STDIN_FILENO)  dup2 (fd, STDIN_FILENO);
3959           if (fd != STDOUT_FILENO) dup2 (fd, STDOUT_FILENO);
3960           if (fd != STDERR_FILENO) dup2 (fd, STDERR_FILENO);
3961         }
3962       execl ("/bin/rmdir", "rmdir", dpath, (char *) 0);
3963       _exit (-1);               /* Can't exec /bin/mkdir */
3964
3965     default:                    /* Parent process */
3966       wait_for_termination (cpid);
3967     }
3968
3969   if (synch_process_death   != 0 ||
3970       synch_process_retcode != 0)
3971     {
3972       errno = EIO;              /* We don't know why, but */
3973       return -1;                /* /bin/rmdir failed */
3974     }
3975
3976   return 0;
3977 }
3978 #endif /* !HAVE_RMDIR */
3979
3980 \f
3981 /************************************************************************/
3982 /*                            Misc. SunOS crap                          */
3983 /************************************************************************/
3984
3985 #ifdef USE_DL_STUBS
3986
3987 /* These are included on Sunos 4.1 when we do not use shared libraries.
3988    X11 libraries may refer to these functions but (we hope) do not
3989    actually call them.  */
3990
3991 void *
3992 dlopen (void)
3993 {
3994   return 0;
3995 }
3996
3997 void *
3998 dlsym (void)
3999 {
4000   return 0;
4001 }
4002
4003 int
4004 dlclose (void)
4005 {
4006   return -1;
4007 }
4008
4009 #endif /* USE_DL_STUBS */
4010
4011 \f
4012
4013 #ifndef HAVE_STRCASECMP
4014 /*
4015  * From BSD
4016  */
4017 static unsigned char charmap[] = {
4018         '\000', '\001', '\002', '\003', '\004', '\005', '\006', '\007',
4019         '\010', '\011', '\012', '\013', '\014', '\015', '\016', '\017',
4020         '\020', '\021', '\022', '\023', '\024', '\025', '\026', '\027',
4021         '\030', '\031', '\032', '\033', '\034', '\035', '\036', '\037',
4022         '\040', '\041', '\042', '\043', '\044', '\045', '\046', '\047',
4023         '\050', '\051', '\052', '\053', '\054', '\055', '\056', '\057',
4024         '\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067',
4025         '\070', '\071', '\072', '\073', '\074', '\075', '\076', '\077',
4026         '\100', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
4027         '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
4028         '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
4029         '\170', '\171', '\172', '\133', '\134', '\135', '\136', '\137',
4030         '\140', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
4031         '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
4032         '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
4033         '\170', '\171', '\172', '\173', '\174', '\175', '\176', '\177',
4034         '\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207',
4035         '\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217',
4036         '\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227',
4037         '\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237',
4038         '\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247',
4039         '\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257',
4040         '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267',
4041         '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277',
4042         '\300', '\301', '\302', '\303', '\304', '\305', '\306', '\307',
4043         '\310', '\311', '\312', '\313', '\314', '\315', '\316', '\317',
4044         '\320', '\321', '\322', '\323', '\324', '\325', '\326', '\327',
4045         '\330', '\331', '\332', '\333', '\334', '\335', '\336', '\337',
4046         '\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347',
4047         '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357',
4048         '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367',
4049         '\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377',
4050 };
4051
4052 int
4053 strcasecmp (char *s1, char *s2)
4054 {
4055   unsigned char *cm = charmap;
4056   unsigned char *us1 = (unsigned char *) s1;
4057   unsigned char *us2 = (unsigned char *)s2;
4058
4059   while (cm[*us1] == cm[*us2++])
4060     if (*us1++ == '\0')
4061       return (0);
4062
4063   return (cm[*us1] - cm[*--us2]);
4064 }
4065 #endif /* !HAVE_STRCASECMP */