gdb/inflow.c

   1 /* Low level interface to ptrace, for GDB when running under Unix.
   2    Copyright 1986, 1987, 1989, 1991, 1992 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include "defs.h"
  21 #include "frame.h"
  22 #include "inferior.h"
  23 #include "command.h"
  24 #include "signals.h"
  25 #include "serial.h"
  26 #include "terminal.h"
  27 #include "target.h"
  28 #include "thread.h"
  29
  30 #include <signal.h>
  31 #include <fcntl.h>
  32
  33 #if !defined (HAVE_TERMIOS) && !defined (HAVE_TERMIO) && !defined (HAVE_SGTTY) && !defined (__GO32__)
  34 #define HAVE_SGTTY
  35 #endif
  36
  37 #if defined (HAVE_TERMIOS)
  38 #include <termios.h>
  39 #include <unistd.h>
  40 #endif
  41
  42 #ifdef HAVE_TERMIOS
  43 #define PROCESS_GROUP_TYPE pid_t
  44 #endif
  45
  46 #ifdef HAVE_SGTTY
  47 #ifdef SHORT_PGRP
  48 /* This is only used for the ultra.  Does it have pid_t?  */
  49 #define PROCESS_GROUP_TYPE short
  50 #else
  51 #define PROCESS_GROUP_TYPE int
  52 #endif
  53 #endif /* sgtty */
  54
  55 static void
  56 kill_command PARAMS ((char *, int));
  57
  58 static void
  59 terminal_ours_1 PARAMS ((int));
  60 \f
  61 /* Record terminal status separately for debugger and inferior.  */
  62
  63 static serial_t stdin_serial;
  64
  65 /* TTY state for the inferior.  We save it whenever the inferior stops, and
  66    restore it when it resumes.  */
  67 static serial_ttystate inferior_ttystate;
  68
  69 /* Our own tty state, which we restore every time we need to deal with the
  70    terminal.  We only set it once, when GDB first starts.  The settings of
  71    flags which readline saves and restores and unimportant.  */
  72 static serial_ttystate our_ttystate;
  73
  74 /* fcntl flags for us and the inferior.  Saved and restored just like
  75    {our,inferior}_ttystate.  */
  76 static int tflags_inferior;
  77 static int tflags_ours;
  78
  79 #ifdef PROCESS_GROUP_TYPE
  80 /* Process group for us and the inferior.  Saved and restored just like
  81    {our,inferior}_ttystate.  */
  82 PROCESS_GROUP_TYPE our_process_group;
  83 PROCESS_GROUP_TYPE inferior_process_group;
  84 #endif
  85
  86 /* While the inferior is running, we want SIGINT and SIGQUIT to go to the
  87    inferior only.  If we have job control, that takes care of it.  If not,
  88    we save our handlers in these two variables and set SIGINT and SIGQUIT
  89    to SIG_IGN.  */
  90 static void (*sigint_ours) ();
  91 static void (*sigquit_ours) ();
  92
  93 /* The name of the tty (from the `tty' command) that we gave to the inferior
  94    when it was last started.  */
  95
  96 static char *inferior_thisrun_terminal;
  97
  98 /* Nonzero if our terminal settings are in effect.  Zero if the
  99    inferior's settings are in effect.  Ignored if !gdb_has_a_terminal
 100    ().  */
 101
 102 static int terminal_is_ours;
 103
 104 enum {yes, no, have_not_checked} gdb_has_a_terminal_flag = have_not_checked;
 105
 106 /* Does GDB have a terminal (on stdin)?  */
 107 int
 108 gdb_has_a_terminal ()
 109 {
 110   switch (gdb_has_a_terminal_flag)
 111     {
 112     case yes:
 113       return 1;
 114     case no:
 115       return 0;
 116     case have_not_checked:
 117       /* Get all the current tty settings (including whether we have a tty at
 118          all!).  Can't do this in _initialize_inflow because SERIAL_FDOPEN
 119          won't work until the serial_ops_list is initialized.  */
 120
 121 #ifdef F_GETFL
 122       tflags_ours = fcntl (0, F_GETFL, 0);
 123 #endif
 124
 125       gdb_has_a_terminal_flag = no;
 126       stdin_serial = SERIAL_FDOPEN (0);
 127       if (stdin_serial != NULL)
 128         {
 129           our_ttystate = SERIAL_GET_TTY_STATE (stdin_serial);
 130
 131           if (our_ttystate != NULL)
 132             {
 133               gdb_has_a_terminal_flag = yes;
 134 #ifdef HAVE_TERMIOS
 135               our_process_group = tcgetpgrp (0);
 136 #endif
 137 #ifdef HAVE_SGTTY
 138               ioctl (0, TIOCGPGRP, &our_process_group);
 139 #endif
 140             }
 141         }
 142
 143       return gdb_has_a_terminal_flag == yes;
 144     default:
 145       /* "Can't happen".  */
 146       return 0;
 147     }
 148 }
 149
 150 /* Macro for printing errors from ioctl operations */
 151
 152 #define OOPSY(what)     \
 153   if (result == -1)     \
 154     fprintf_unfiltered(gdb_stderr, "[%s failed in terminal_inferior: %s]\n", \
 155             what, strerror (errno))
 156
 157 static void terminal_ours_1 PARAMS ((int));
 158
 159 /* Initialize the terminal settings we record for the inferior,
 160    before we actually run the inferior.  */
 161
 162 void
 163 terminal_init_inferior ()
 164 {
 165   if (gdb_has_a_terminal ())
 166     {
 167       /* We could just as well copy our_ttystate (if we felt like adding
 168          a new function SERIAL_COPY_TTY_STATE).  */
 169       if (inferior_ttystate)
 170         free (inferior_ttystate);
 171       inferior_ttystate = SERIAL_GET_TTY_STATE (stdin_serial);
 172 #ifdef PROCESS_GROUP_TYPE
 173 #ifdef PIDGET
 174       /* This is for Lynx, and should be cleaned up by having Lynx be
 175          a separate debugging target with a version of
 176          target_terminal_init_inferior which passes in the process
 177          group to a generic routine which does all the work (and the
 178          non-threaded child_terminal_init_inferior can just pass in
 179          inferior_pid to the same routine).  */
 180       inferior_process_group = PIDGET (inferior_pid);
 181 #else
 182       inferior_process_group = inferior_pid;
 183 #endif
 184 #endif
 185
 186       /* Make sure that next time we call terminal_inferior (which will be
 187          before the program runs, as it needs to be), we install the new
 188          process group.  */
 189       terminal_is_ours = 1;
 190     }
 191 }
 192
 193 /* Put the inferior's terminal settings into effect.
 194    This is preparation for starting or resuming the inferior.  */
 195
 196 void
 197 terminal_inferior ()
 198 {
 199   if (gdb_has_a_terminal () && terminal_is_ours
 200       && inferior_thisrun_terminal == 0)
 201     {
 202       int result;
 203
 204 #ifdef F_GETFL
 205       /* Is there a reason this is being done twice?  It happens both
 206          places we use F_SETFL, so I'm inclined to think perhaps there
 207          is some reason, however perverse.  Perhaps not though...  */
 208       result = fcntl (0, F_SETFL, tflags_inferior);
 209       result = fcntl (0, F_SETFL, tflags_inferior);
 210       OOPSY ("fcntl F_SETFL");
 211 #endif
 212
 213       /* Because we were careful to not change in or out of raw mode in
 214          terminal_ours, we will not change in our out of raw mode with
 215          this call, so we don't flush any input.  */
 216       result = SERIAL_SET_TTY_STATE (stdin_serial, inferior_ttystate);
 217       OOPSY ("setting tty state");
 218
 219       if (!job_control)
 220         {
 221           sigint_ours = (void (*) ()) signal (SIGINT, SIG_IGN);
 222           sigquit_ours = (void (*) ()) signal (SIGQUIT, SIG_IGN);
 223         }
 224
 225       /* If attach_flag is set, we don't know whether we are sharing a
 226          terminal with the inferior or not.  (attaching a process
 227          without a terminal is one case where we do not; attaching a
 228          process which we ran from the same shell as GDB via `&' is
 229          one case where we do, I think (but perhaps this is not
 230          `sharing' in the sense that we need to save and restore tty
 231          state)).  I don't know if there is any way to tell whether we
 232          are sharing a terminal.  So what we do is to go through all
 233          the saving and restoring of the tty state, but ignore errors
 234          setting the process group, which will happen if we are not
 235          sharing a terminal).  */
 236
 237       if (job_control)
 238         {
 239 #ifdef HAVE_TERMIOS
 240           result = tcsetpgrp (0, inferior_process_group);
 241           if (!attach_flag)
 242             OOPSY ("tcsetpgrp");
 243 #endif
 244
 245 #ifdef HAVE_SGTTY
 246           result = ioctl (0, TIOCSPGRP, &inferior_process_group);
 247           if (!attach_flag)
 248             OOPSY ("TIOCSPGRP");
 249 #endif
 250         }
 251
 252     }
 253   terminal_is_ours = 0;
 254 }
 255
 256 /* Put some of our terminal settings into effect,
 257    enough to get proper results from our output,
 258    but do not change into or out of RAW mode
 259    so that no input is discarded.
 260
 261    After doing this, either terminal_ours or terminal_inferior
 262    should be called to get back to a normal state of affairs.  */
 263
 264 void
 265 terminal_ours_for_output ()
 266 {
 267   terminal_ours_1 (1);
 268 }
 269
 270 /* Put our terminal settings into effect.
 271    First record the inferior's terminal settings
 272    so they can be restored properly later.  */
 273
 274 void
 275 terminal_ours ()
 276 {
 277   terminal_ours_1 (0);
 278 }
 279
 280 /* output_only is not used, and should not be used unless we introduce
 281    separate terminal_is_ours and terminal_is_ours_for_output
 282    flags.  */
 283
 284 static void
 285 terminal_ours_1 (output_only)
 286      int output_only;
 287 {
 288   /* Checking inferior_thisrun_terminal is necessary so that
 289      if GDB is running in the background, it won't block trying
 290      to do the ioctl()'s below.  Checking gdb_has_a_terminal
 291      avoids attempting all the ioctl's when running in batch.  */
 292   if (inferior_thisrun_terminal != 0 || gdb_has_a_terminal () == 0)
 293     return;
 294
 295   if (!terminal_is_ours)
 296     {
 297       /* Ignore this signal since it will happen when we try to set the
 298          pgrp.  */
 299       void (*osigttou) ();
 300       int result;
 301
 302       terminal_is_ours = 1;
 303
 304 #ifdef SIGTTOU
 305       if (job_control)
 306         osigttou = (void (*) ()) signal (SIGTTOU, SIG_IGN);
 307 #endif
 308
 309       if (inferior_ttystate)
 310         free (inferior_ttystate);
 311       inferior_ttystate = SERIAL_GET_TTY_STATE (stdin_serial);
 312 #ifdef HAVE_TERMIOS
 313       inferior_process_group = tcgetpgrp (0);
 314 #endif
 315 #ifdef HAVE_SGTTY
 316       ioctl (0, TIOCGPGRP, &inferior_process_group);
 317 #endif
 318
 319       /* Here we used to set ICANON in our ttystate, but I believe this
 320          was an artifact from before when we used readline.  Readline sets
 321          the tty state when it needs to.
 322          FIXME-maybe: However, query() expects non-raw mode and doesn't
 323          use readline.  Maybe query should use readline (on the other hand,
 324          this only matters for HAVE_SGTTY, not termio or termios, I think).  */
 325
 326       /* Set tty state to our_ttystate.  We don't change in our out of raw
 327          mode, to avoid flushing input.  We need to do the same thing
 328          regardless of output_only, because we don't have separate
 329          terminal_is_ours and terminal_is_ours_for_output flags.  It's OK,
 330          though, since readline will deal with raw mode when/if it needs to.
 331          */
 332
 333       SERIAL_NOFLUSH_SET_TTY_STATE (stdin_serial, our_ttystate,
 334                                     inferior_ttystate);
 335
 336       if (job_control)
 337         {
 338 #ifdef HAVE_TERMIOS
 339           result = tcsetpgrp (0, our_process_group);
 340 #if 0
 341           /* This fails on Ultrix with EINVAL if you run the testsuite
 342              in the background with nohup, and then log out.  GDB never
 343              used to check for an error here, so perhaps there are other
 344              such situations as well.  */
 345           if (result == -1)
 346             fprintf_unfiltered (gdb_stderr, "[tcsetpgrp failed in terminal_ours: %s]\n",
 347                      strerror (errno));
 348 #endif
 349 #endif /* termios */
 350
 351 #ifdef HAVE_SGTTY
 352           result = ioctl (0, TIOCSPGRP, &our_process_group);
 353 #endif
 354         }
 355
 356 #ifdef SIGTTOU
 357       if (job_control)
 358         signal (SIGTTOU, osigttou);
 359 #endif
 360
 361       if (!job_control)
 362         {
 363           signal (SIGINT, sigint_ours);
 364           signal (SIGQUIT, sigquit_ours);
 365         }
 366
 367 #ifdef F_GETFL
 368       tflags_inferior = fcntl (0, F_GETFL, 0);
 369
 370       /* Is there a reason this is being done twice?  It happens both
 371          places we use F_SETFL, so I'm inclined to think perhaps there
 372          is some reason, however perverse.  Perhaps not though...  */
 373       result = fcntl (0, F_SETFL, tflags_ours);
 374       result = fcntl (0, F_SETFL, tflags_ours);
 375 #endif
 376
 377       result = result;  /* lint */
 378     }
 379 }
 380
 381 /* ARGSUSED */
 382 void
 383 term_info (arg, from_tty)
 384      char *arg;
 385      int from_tty;
 386 {
 387   target_terminal_info (arg, from_tty);
 388 }
 389
 390 /* ARGSUSED */
 391 void
 392 child_terminal_info (args, from_tty)
 393      char *args;
 394      int from_tty;
 395 {
 396   if (!gdb_has_a_terminal ())
 397     {
 398       printf_filtered ("This GDB does not control a terminal.\n");
 399       return;
 400     }
 401
 402   printf_filtered ("Inferior's terminal status (currently saved by GDB):\n");
 403
 404   /* First the fcntl flags.  */
 405   {
 406     int flags;
 407
 408     flags = tflags_inferior;
 409
 410     printf_filtered ("File descriptor flags = ");
 411
 412 #ifndef O_ACCMODE
 413 #define O_ACCMODE (O_RDONLY | O_WRONLY | O_RDWR)
 414 #endif
 415     /* (O_ACCMODE) parens are to avoid Ultrix header file bug */
 416     switch (flags & (O_ACCMODE))
 417       {
 418       case O_RDONLY: printf_filtered ("O_RDONLY"); break;
 419       case O_WRONLY: printf_filtered ("O_WRONLY"); break;
 420       case O_RDWR: printf_filtered ("O_RDWR"); break;
 421       }
 422     flags &= ~(O_ACCMODE);
 423
 424 #ifdef O_NONBLOCK
 425     if (flags & O_NONBLOCK)
 426       printf_filtered (" | O_NONBLOCK");
 427     flags &= ~O_NONBLOCK;
 428 #endif
 429
 430 #if defined (O_NDELAY)
 431     /* If O_NDELAY and O_NONBLOCK are defined to the same thing, we will
 432        print it as O_NONBLOCK, which is good cause that is what POSIX
 433        has, and the flag will already be cleared by the time we get here.  */
 434     if (flags & O_NDELAY)
 435       printf_filtered (" | O_NDELAY");
 436     flags &= ~O_NDELAY;
 437 #endif
 438
 439     if (flags & O_APPEND)
 440       printf_filtered (" | O_APPEND");
 441     flags &= ~O_APPEND;
 442
 443 #if defined (O_BINARY)
 444     if (flags & O_BINARY)
 445       printf_filtered (" | O_BINARY");
 446     flags &= ~O_BINARY;
 447 #endif
 448
 449     if (flags)
 450       printf_filtered (" | 0x%x", flags);
 451     printf_filtered ("\n");
 452   }
 453
 454 #ifdef PROCESS_GROUP_TYPE
 455   printf_filtered ("Process group = %d\n", inferior_process_group);
 456 #endif
 457
 458   SERIAL_PRINT_TTY_STATE (stdin_serial, inferior_ttystate);
 459 }
 460 \f
 461 /* NEW_TTY_PREFORK is called before forking a new child process,
 462    so we can record the state of ttys in the child to be formed.
 463    TTYNAME is null if we are to share the terminal with gdb;
 464    or points to a string containing the name of the desired tty.
 465
 466    NEW_TTY is called in new child processes under Unix, which will
 467    become debugger target processes.  This actually switches to
 468    the terminal specified in the NEW_TTY_PREFORK call.  */
 469
 470 void
 471 new_tty_prefork (ttyname)
 472      char *ttyname;
 473 {
 474   /* Save the name for later, for determining whether we and the child
 475      are sharing a tty.  */
 476   inferior_thisrun_terminal = ttyname;
 477 }
 478
 479 void
 480 new_tty ()
 481 {
 482   register int tty;
 483
 484   if (inferior_thisrun_terminal == 0)
 485     return;
 486 #if !defined(__GO32__)
 487 #ifdef TIOCNOTTY
 488   /* Disconnect the child process from our controlling terminal.  On some
 489      systems (SVR4 for example), this may cause a SIGTTOU, so temporarily
 490      ignore SIGTTOU. */
 491   tty = open("/dev/tty", O_RDWR);
 492   if (tty > 0)
 493     {
 494       void (*osigttou) ();
 495
 496       osigttou = (void (*)()) signal(SIGTTOU, SIG_IGN);
 497       ioctl(tty, TIOCNOTTY, 0);
 498       close(tty);
 499       signal(SIGTTOU, osigttou);
 500     }
 501 #endif
 502
 503   /* Now open the specified new terminal.  */
 504
 505 #ifdef USE_O_NOCTTY
 506   tty = open(inferior_thisrun_terminal, O_RDWR | O_NOCTTY);
 507 #else
 508   tty = open(inferior_thisrun_terminal, O_RDWR);
 509 #endif
 510   if (tty == -1)
 511     {
 512       print_sys_errmsg (inferior_thisrun_terminal, errno);
 513       _exit(1);
 514     }
 515
 516   /* Avoid use of dup2; doesn't exist on all systems.  */
 517   if (tty != 0)
 518     { close (0); dup (tty); }
 519   if (tty != 1)
 520     { close (1); dup (tty); }
 521   if (tty != 2)
 522     { close (2); dup (tty); }
 523   if (tty > 2)
 524     close(tty);
 525 #endif /* !go32 */
 526 }
 527 \f
 528 /* Kill the inferior process.  Make us have no inferior.  */
 529
 530 /* ARGSUSED */
 531 static void
 532 kill_command (arg, from_tty)
 533      char *arg;
 534      int from_tty;
 535 {
 536   if (!target_has_execution)
 537     error ("The program is not being run.");
 538   if (!query ("Kill the program being debugged? "))
 539     error ("Not confirmed.");
 540   target_kill ();
 541
 542   init_thread_list();           /* Destroy thread info */
 543
 544   /* Killing off the inferior can leave us with a core file.  If so,
 545      print the state we are left in.  */
 546   if (target_has_stack) {
 547     printf_filtered ("In %s,\n", target_longname);
 548     if (selected_frame == NULL)
 549       fputs_filtered ("No selected stack frame.\n", gdb_stdout);
 550     else
 551       print_stack_frame (selected_frame, selected_frame_level, 1);
 552   }
 553 }
 554 \f
 555 /* Call set_sigint_trap when you need to pass a signal on to an attached
 556    process when handling SIGINT */
 557
 558 /* ARGSUSED */
 559 static void
 560 pass_signal (signo)
 561     int signo;
 562 {
 563   kill (inferior_pid, SIGINT);
 564 }
 565
 566 static void (*osig)();
 567
 568 void
 569 set_sigint_trap()
 570 {
 571   osig = (void (*) ()) signal (SIGINT, pass_signal);
 572 }
 573
 574 void
 575 clear_sigint_trap()
 576 {
 577   signal (SIGINT, osig);
 578 }
 579 \f
 580 #if defined (SIGIO) && defined (FASYNC) && defined (FD_SET) && defined (F_SETOWN)
 581 static void (*old_sigio) ();
 582
 583 static void
 584 handle_sigio (signo)
 585      int signo;
 586 {
 587   int numfds;
 588   fd_set readfds;
 589
 590   signal (SIGIO, handle_sigio);
 591
 592   FD_ZERO (&readfds);
 593   FD_SET (target_activity_fd, &readfds);
 594   numfds = select (target_activity_fd + 1, &readfds, NULL, NULL, NULL);
 595   if (numfds >= 0 && FD_ISSET (target_activity_fd, &readfds))
 596     {
 597       if ((*target_activity_function) ())
 598         kill (inferior_pid, SIGINT);
 599     }
 600 }
 601
 602 static int old_fcntl_flags;
 603
 604 void
 605 set_sigio_trap ()
 606 {
 607   if (target_activity_function)
 608     {
 609       old_sigio = (void (*) ()) signal (SIGIO, handle_sigio);
 610       fcntl (target_activity_fd, F_SETOWN, getpid());
 611       old_fcntl_flags = fcntl (target_activity_fd, F_GETFL, 0);
 612       fcntl (target_activity_fd, F_SETFL, old_fcntl_flags | FASYNC);
 613     }
 614 }
 615
 616 void
 617 clear_sigio_trap ()
 618 {
 619   if (target_activity_function)
 620     {
 621       signal (SIGIO, old_sigio);
 622       fcntl (target_activity_fd, F_SETFL, old_fcntl_flags);
 623     }
 624 }
 625 #else /* No SIGIO.  */
 626 void
 627 set_sigio_trap ()
 628 {
 629   if (target_activity_function)
 630     abort ();
 631 }
 632
 633 void
 634 clear_sigio_trap ()
 635 {
 636   if (target_activity_function)
 637     abort ();
 638 }
 639 #endif /* No SIGIO.  */
 640 \f
 641
 642 /* This is here because this is where we figure out whether we (probably)
 643    have job control.  Just using job_control only does part of it because
 644    setpgid or setpgrp might not exist on a system without job control.
 645    It might be considered misplaced (on the other hand, process groups and
 646    job control are closely related to ttys).
 647
 648    For a more clean implementation, in libiberty, put a setpgid which merely
 649    calls setpgrp and a setpgrp which does nothing (any system with job control
 650    will have one or the other).  */
 651 int
 652 gdb_setpgid ()
 653 {
 654   int retval = 0;
 655
 656   if (job_control)
 657     {
 658 #if defined (NEED_POSIX_SETPGID) || defined (HAVE_TERMIOS)
 659       /* Do all systems with termios have setpgid?  I hope so.  */
 660       /* setpgid (0, 0) is supposed to work and mean the same thing as
 661          this, but on Ultrix 4.2A it fails with EPERM (and
 662          setpgid (getpid (), getpid ()) succeeds).  */
 663       retval = setpgid (getpid (), getpid ());
 664 #else
 665 #if defined (TIOCGPGRP)
 666 #if defined(USG) && !defined(SETPGRP_ARGS)
 667       retval = setpgrp ();
 668 #else
 669       retval = setpgrp (getpid (), getpid ());
 670 #endif /* USG */
 671 #endif /* TIOCGPGRP.  */
 672 #endif /* NEED_POSIX_SETPGID */
 673     }
 674   return retval;
 675 }
 676
 677 void
 678 _initialize_inflow ()
 679 {
 680   add_info ("terminal", term_info,
 681            "Print inferior's saved terminal status.");
 682
 683   add_com ("kill", class_run, kill_command,
 684            "Kill execution of program being debugged.");
 685
 686   inferior_pid = 0;
 687
 688   terminal_is_ours = 1;
 689
 690   /* OK, figure out whether we have job control.  If neither termios nor
 691      sgtty (i.e. termio or go32), leave job_control 0.  */
 692
 693 #if defined (HAVE_TERMIOS)
 694   /* Do all systems with termios have the POSIX way of identifying job
 695      control?  I hope so.  */
 696 #ifdef _POSIX_JOB_CONTROL
 697   job_control = 1;
 698 #else
 699   job_control = sysconf (_SC_JOB_CONTROL);
 700 #endif
 701 #endif /* termios */
 702
 703 #ifdef HAVE_SGTTY
 704 #ifdef TIOCGPGRP
 705   job_control = 1;
 706 #else
 707   job_control = 0;
 708 #endif /* TIOCGPGRP */
 709 #endif /* sgtty */
 710 }