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   /* Shouldn't this be target_has_execution?  FIXME.  */
 537   if (inferior_pid == 0)
 538     error ("The program is not being run.");
 539   if (!query ("Kill the program being debugged? "))
 540     error ("Not confirmed.");
 541   target_kill ();
 542
 543   init_thread_list();           /* Destroy thread info */
 544
 545   /* Killing off the inferior can leave us with a core file.  If so,
 546      print the state we are left in.  */
 547   if (target_has_stack) {
 548     printf_filtered ("In %s,\n", target_longname);
 549     if (selected_frame == NULL)
 550       fputs_filtered ("No selected stack frame.\n", gdb_stdout);
 551     else
 552       print_stack_frame (selected_frame, selected_frame_level, 1);
 553   }
 554 }
 555 \f
 556 /* Call set_sigint_trap when you need to pass a signal on to an attached
 557    process when handling SIGINT */
 558
 559 /* ARGSUSED */
 560 static void
 561 pass_signal (signo)
 562     int signo;
 563 {
 564   kill (inferior_pid, SIGINT);
 565 }
 566
 567 static void (*osig)();
 568
 569 void
 570 set_sigint_trap()
 571 {
 572   osig = (void (*) ()) signal (SIGINT, pass_signal);
 573 }
 574
 575 void
 576 clear_sigint_trap()
 577 {
 578   signal (SIGINT, osig);
 579 }
 580 \f
 581 #if defined (SIGIO) && defined (FASYNC) && defined (FD_SET) && defined (F_SETOWN)
 582 static void (*old_sigio) ();
 583
 584 static void
 585 handle_sigio (signo)
 586      int signo;
 587 {
 588   int numfds;
 589   fd_set readfds;
 590
 591   signal (SIGIO, handle_sigio);
 592
 593   FD_ZERO (&readfds);
 594   FD_SET (target_activity_fd, &readfds);
 595   numfds = select (target_activity_fd + 1, &readfds, NULL, NULL, NULL);
 596   if (numfds >= 0 && FD_ISSET (target_activity_fd, &readfds))
 597     {
 598       if ((*target_activity_function) ())
 599         kill (inferior_pid, SIGINT);
 600     }
 601 }
 602
 603 static int old_fcntl_flags;
 604
 605 void
 606 set_sigio_trap ()
 607 {
 608   if (target_activity_function)
 609     {
 610       old_sigio = (void (*) ()) signal (SIGIO, handle_sigio);
 611       fcntl (target_activity_fd, F_SETOWN, getpid());
 612       old_fcntl_flags = fcntl (target_activity_fd, F_GETFL, 0);
 613       fcntl (target_activity_fd, F_SETFL, old_fcntl_flags | FASYNC);
 614     }
 615 }
 616
 617 void
 618 clear_sigio_trap ()
 619 {
 620   if (target_activity_function)
 621     {
 622       signal (SIGIO, old_sigio);
 623       fcntl (target_activity_fd, F_SETFL, old_fcntl_flags);
 624     }
 625 }
 626 #else /* No SIGIO.  */
 627 void
 628 set_sigio_trap ()
 629 {
 630   if (target_activity_function)
 631     abort ();
 632 }
 633
 634 void
 635 clear_sigio_trap ()
 636 {
 637   if (target_activity_function)
 638     abort ();
 639 }
 640 #endif /* No SIGIO.  */
 641 \f
 642
 643 /* This is here because this is where we figure out whether we (probably)
 644    have job control.  Just using job_control only does part of it because
 645    setpgid or setpgrp might not exist on a system without job control.
 646    It might be considered misplaced (on the other hand, process groups and
 647    job control are closely related to ttys).
 648
 649    For a more clean implementation, in libiberty, put a setpgid which merely
 650    calls setpgrp and a setpgrp which does nothing (any system with job control
 651    will have one or the other).  */
 652 int
 653 gdb_setpgid ()
 654 {
 655   int retval = 0;
 656
 657   if (job_control)
 658     {
 659 #if defined (NEED_POSIX_SETPGID) || defined (HAVE_TERMIOS)
 660       /* Do all systems with termios have setpgid?  I hope so.  */
 661       /* setpgid (0, 0) is supposed to work and mean the same thing as
 662          this, but on Ultrix 4.2A it fails with EPERM (and
 663          setpgid (getpid (), getpid ()) succeeds).  */
 664       retval = setpgid (getpid (), getpid ());
 665 #else
 666 #if defined (TIOCGPGRP)
 667 #if defined(USG) && !defined(SETPGRP_ARGS)
 668       retval = setpgrp ();
 669 #else
 670       retval = setpgrp (getpid (), getpid ());
 671 #endif /* USG */
 672 #endif /* TIOCGPGRP.  */
 673 #endif /* NEED_POSIX_SETPGID */
 674     }
 675   return retval;
 676 }
 677
 678 void
 679 _initialize_inflow ()
 680 {
 681   add_info ("terminal", term_info,
 682            "Print inferior's saved terminal status.");
 683
 684   add_com ("kill", class_run, kill_command,
 685            "Kill execution of program being debugged.");
 686
 687   inferior_pid = 0;
 688
 689   terminal_is_ours = 1;
 690
 691   /* OK, figure out whether we have job control.  If neither termios nor
 692      sgtty (i.e. termio or go32), leave job_control 0.  */
 693
 694 #if defined (HAVE_TERMIOS)
 695   /* Do all systems with termios have the POSIX way of identifying job
 696      control?  I hope so.  */
 697 #ifdef _POSIX_JOB_CONTROL
 698   job_control = 1;
 699 #else
 700   job_control = sysconf (_SC_JOB_CONTROL);
 701 #endif
 702 #endif /* termios */
 703
 704 #ifdef HAVE_SGTTY
 705 #ifdef TIOCGPGRP
 706   job_control = 1;
 707 #else
 708   job_control = 0;
 709 #endif /* TIOCGPGRP */
 710 #endif /* sgtty */
 711 }