src/subshell.c

   1 /*
   2    Concurrent shell support for the Midnight Commander
   3
   4    Copyright (C) 1994, 1995, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
   5    2005, 2006, 2007, 2011, 2013
   6    The Free Software Foundation, Inc.
   7
   8    Written by:
   9    Slava Zanko <slavazanko@gmail.com>, 2013
  10
  11    This file is part of the Midnight Commander.
  12
  13    The Midnight Commander is free software: you can redistribute it
  14    and/or modify it under the terms of the GNU General Public License as
  15    published by the Free Software Foundation, either version 3 of the License,
  16    or (at your option) any later version.
  17
  18    The Midnight Commander is distributed in the hope that it will be useful,
  19    but WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21    GNU General Public License for more details.
  22
  23    You should have received a copy of the GNU General Public License
  24    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  25  */
  26
  27 /** \file subshell.c
  28  *  \brief Source: concurrent shell support
  29  */
  30
  31 #include <config.h>
  32
  33 #ifndef _GNU_SOURCE
  34 #define _GNU_SOURCE 1
  35 #endif
  36
  37 #include <ctype.h>
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40 #include <errno.h>
  41 #include <string.h>
  42 #include <signal.h>
  43 #include <fcntl.h>
  44 #include <sys/types.h>
  45 #include <sys/wait.h>
  46 #ifdef HAVE_SYS_IOCTL_H
  47 #include <sys/ioctl.h>
  48 #endif
  49 #include <termios.h>
  50 #include <unistd.h>
  51
  52 #ifdef HAVE_STROPTS_H
  53 #include <stropts.h>            /* For I_PUSH */
  54 #endif /* HAVE_STROPTS_H */
  55
  56 #include "lib/global.h"
  57
  58 #include "lib/tty/tty.h"        /* LINES */
  59 #include "lib/tty/key.h"        /* XCTRL */
  60 #include "lib/vfs/vfs.h"
  61 #include "lib/strutil.h"
  62 #include "lib/mcconfig.h"
  63 #include "lib/util.h"
  64 #include "lib/widget.h"
  65
  66 #include "filemanager/midnight.h"       /* current_panel */
  67
  68 #include "consaver/cons.saver.h"        /* handle_console() */
  69 #include "setup.h"
  70 #include "subshell.h"
  71
  72 /*** global variables ****************************************************************************/
  73
  74 /* State of the subshell:
  75  * INACTIVE: the default state; awaiting a command
  76  * ACTIVE: remain in the shell until the user hits 'subshell_switch_key'
  77  * RUNNING_COMMAND: return to MC when the current command finishes */
  78 enum subshell_state_enum subshell_state;
  79
  80 /* Holds the latest prompt captured from the subshell */
  81 GString *subshell_prompt = NULL;
  82
  83 /* Subshell: if set, then the prompt was not saved on CONSOLE_SAVE */
  84 /* We need to paint it after CONSOLE_RESTORE, see: load_prompt */
  85 gboolean update_subshell_prompt = FALSE;
  86
  87 /*** file scope macro definitions ****************************************************************/
  88
  89 #ifndef WEXITSTATUS
  90 #define WEXITSTATUS(stat_val) ((unsigned)(stat_val) >> 8)
  91 #endif
  92
  93 #ifndef WIFEXITED
  94 #define WIFEXITED(stat_val) (((stat_val) & 255) == 0)
  95 #endif
  96
  97 #ifndef STDIN_FILENO
  98 #define STDIN_FILENO 0
  99 #endif
 100
 101 #ifndef STDOUT_FILENO
 102 #define STDOUT_FILENO 1
 103 #endif
 104
 105 #ifndef STDERR_FILENO
 106 #define STDERR_FILENO 2
 107 #endif
 108
 109 /* Initial length of the buffer for the subshell's prompt */
 110 #define INITIAL_PROMPT_SIZE 10
 111
 112 /* Used by the child process to indicate failure to start the subshell */
 113 #define FORK_FAILURE 69         /* Arbitrary */
 114
 115 /* Length of the buffer for all I/O with the subshell */
 116 #define PTY_BUFFER_SIZE BUF_SMALL       /* Arbitrary; but keep it >= 80 */
 117
 118 /*** file scope type declarations ****************************************************************/
 119
 120 /* For pipes */
 121 enum
 122 {
 123     READ = 0,
 124     WRITE = 1
 125 };
 126
 127 /* Subshell type (gleaned from the SHELL environment variable, if available) */
 128 static enum
 129 {
 130     BASH,
 131     TCSH,
 132     ZSH,
 133     FISH
 134 } subshell_type;
 135
 136 /*** file scope variables ************************************************************************/
 137
 138 /* tcsh closes all non-standard file descriptors, so we have to use a pipe */
 139 static char tcsh_fifo[128];
 140
 141 static int subshell_pty_slave = -1;
 142
 143 /* The key for switching back to MC from the subshell */
 144 /* *INDENT-OFF* */
 145 static const char subshell_switch_key = XCTRL ('o') & 255;
 146 /* *INDENT-ON* */
 147
 148 /* For reading/writing on the subshell's pty */
 149 static char pty_buffer[PTY_BUFFER_SIZE] = "\0";
 150
 151 /* To pass CWD info from the subshell to MC */
 152 static int subshell_pipe[2];
 153
 154 /* The subshell's process ID */
 155 static pid_t subshell_pid = 1;
 156
 157 /* One extra char for final '\n' */
 158 static char subshell_cwd[MC_MAXPATHLEN + 1];
 159
 160 /* Flag to indicate whether the subshell is ready for next command */
 161 static int subshell_ready;
 162
 163 /* The following two flags can be changed by the SIGCHLD handler. This is */
 164 /* OK, because the 'int' type is updated atomically on all known machines */
 165 static volatile int subshell_alive, subshell_stopped;
 166
 167 /* We store the terminal's initial mode here so that we can configure
 168    the pty similarly, and also so we can restore the real terminal to
 169    sanity if we have to exit abruptly */
 170 static struct termios shell_mode;
 171
 172 /* This is a transparent mode for the terminal where MC is running on */
 173 /* It is used when the shell is active, so that the control signals */
 174 /* are delivered to the shell pty */
 175 static struct termios raw_mode;
 176
 177 /* This counter indicates how many characters of prompt we have read */
 178 /* FIXME: try to figure out why this had to become global */
 179 static int prompt_pos;
 180
 181
 182 /*** file scope functions ************************************************************************/
 183 /* --------------------------------------------------------------------------------------------- */
 184 /**
 185  *  Write all data, even if the write() call is interrupted.
 186  */
 187
 188 static ssize_t
 189 write_all (int fd, const void *buf, size_t count)
 190 {
 191     ssize_t ret;
 192     ssize_t written = 0;
 193     while (count > 0)
 194     {
 195         ret = write (fd, (const unsigned char *) buf + written, count);
 196         if (ret < 0)
 197         {
 198             if (errno == EINTR)
 199             {
 200                 if (mc_global.tty.winch_flag != 0)
 201                     tty_change_screen_size ();
 202
 203                 continue;
 204             }
 205
 206             return written > 0 ? written : ret;
 207         }
 208         count -= ret;
 209         written += ret;
 210     }
 211     return written;
 212 }
 213
 214 /* --------------------------------------------------------------------------------------------- */
 215 /**
 216  *  Prepare child process to running the shell and run it.
 217  *
 218  *  Modifies the global variables (in the child process only):
 219  *      shell_mode
 220  *
 221  *  Returns: never.
 222  */
 223
 224 static void
 225 init_subshell_child (const char *pty_name)
 226 {
 227     char *init_file = NULL;
 228     pid_t mc_sid;
 229
 230     (void) pty_name;
 231     setsid ();                  /* Get a fresh terminal session */
 232
 233     /* Make sure that it has become our controlling terminal */
 234
 235     /* Redundant on Linux and probably most systems, but just in case: */
 236
 237 #ifdef TIOCSCTTY
 238     ioctl (subshell_pty_slave, TIOCSCTTY, 0);
 239 #endif
 240
 241     /* Configure its terminal modes and window size */
 242
 243     /* Set up the pty with the same termios flags as our own tty */
 244     if (tcsetattr (subshell_pty_slave, TCSANOW, &shell_mode))
 245     {
 246         fprintf (stderr, "Cannot set pty terminal modes: %s\r\n", unix_error_string (errno));
 247         my_exit (FORK_FAILURE);
 248     }
 249
 250     /* Set the pty's size (80x25 by default on Linux) according to the */
 251     /* size of the real terminal as calculated by ncurses, if possible */
 252     tty_resize (subshell_pty_slave);
 253
 254     /* Set up the subshell's environment and init file name */
 255
 256     /* It simplifies things to change to our home directory here, */
 257     /* and the user's startup file may do a 'cd' command anyway   */
 258     {
 259         int ret;
 260         ret = chdir (mc_config_get_home_dir ());        /* FIXME? What about when we re-run the subshell? */
 261         (void) ret;
 262     }
 263
 264     /* Set MC_SID to prevent running one mc from another */
 265     mc_sid = getsid (0);
 266     if (mc_sid != -1)
 267     {
 268         char sid_str[BUF_SMALL];
 269         g_snprintf (sid_str, sizeof (sid_str), "MC_SID=%ld", (long) mc_sid);
 270         putenv (g_strdup (sid_str));
 271     }
 272
 273     switch (subshell_type)
 274     {
 275     case BASH:
 276         init_file = mc_config_get_full_path ("bashrc");
 277
 278         if (access (init_file, R_OK) == -1)
 279         {
 280             g_free (init_file);
 281             init_file = g_strdup (".bashrc");
 282         }
 283
 284         /* Make MC's special commands not show up in bash's history */
 285         putenv ((char *) "HISTCONTROL=ignorespace");
 286
 287         /* Allow alternative readline settings for MC */
 288         {
 289             char *input_file = mc_config_get_full_path ("inputrc");
 290             if (access (input_file, R_OK) == 0)
 291             {
 292                 char *putenv_str = g_strconcat ("INPUTRC=", input_file, NULL);
 293                 putenv (putenv_str);
 294                 g_free (putenv_str);
 295             }
 296             g_free (input_file);
 297         }
 298
 299         break;
 300
 301         /* TODO: Find a way to pass initfile to TCSH and ZSH */
 302     case TCSH:
 303     case ZSH:
 304     case FISH:
 305         break;
 306
 307     default:
 308         fprintf (stderr, __FILE__ ": unimplemented subshell type %d\r\n", subshell_type);
 309         my_exit (FORK_FAILURE);
 310     }
 311
 312     /* Attach all our standard file descriptors to the pty */
 313
 314     /* This is done just before the fork, because stderr must still      */
 315     /* be connected to the real tty during the above error messages; */
 316     /* otherwise the user will never see them.                   */
 317
 318     dup2 (subshell_pty_slave, STDIN_FILENO);
 319     dup2 (subshell_pty_slave, STDOUT_FILENO);
 320     dup2 (subshell_pty_slave, STDERR_FILENO);
 321
 322     close (subshell_pipe[READ]);
 323     close (subshell_pty_slave); /* These may be FD_CLOEXEC, but just in case... */
 324     /* Close master side of pty.  This is important; apart from */
 325     /* freeing up the descriptor for use in the subshell, it also       */
 326     /* means that when MC exits, the subshell will get a SIGHUP and     */
 327     /* exit too, because there will be no more descriptors pointing     */
 328     /* at the master side of the pty and so it will disappear.  */
 329     close (mc_global.tty.subshell_pty);
 330
 331     /* Execute the subshell at last */
 332
 333     switch (subshell_type)
 334     {
 335     case BASH:
 336         execl (mc_global.tty.shell, "bash", "-rcfile", init_file, (char *) NULL);
 337         break;
 338
 339     case TCSH:
 340         execl (mc_global.tty.shell, "tcsh", (char *) NULL);
 341         break;
 342
 343     case ZSH:
 344         /* Use -g to exclude cmds beginning with space from history
 345          * and -Z to use the line editor on non-interactive term */
 346         execl (mc_global.tty.shell, "zsh", "-Z", "-g", (char *) NULL);
 347
 348         break;
 349
 350     case FISH:
 351         execl (mc_global.tty.shell, "fish", (char *) NULL);
 352         break;
 353     }
 354
 355     /* If we get this far, everything failed miserably */
 356     g_free (init_file);
 357     my_exit (FORK_FAILURE);
 358 }
 359
 360
 361 /* --------------------------------------------------------------------------------------------- */
 362 /**
 363  * Check MC_SID to prevent running one mc from another.
 364  * Return:
 365  * 0 if no parent mc in our session was found,
 366  * 1 if parent mc was found and the user wants to continue,
 367  * 2 if parent mc was found and the user wants to quit mc.
 368  */
 369
 370 static int
 371 check_sid (void)
 372 {
 373     pid_t my_sid, old_sid;
 374     const char *sid_str;
 375     int r;
 376
 377     sid_str = getenv ("MC_SID");
 378     if (!sid_str)
 379         return 0;
 380
 381     old_sid = (pid_t) strtol (sid_str, NULL, 0);
 382     if (!old_sid)
 383         return 0;
 384
 385     my_sid = getsid (0);
 386     if (my_sid == -1)
 387         return 0;
 388
 389     /* The parent mc is in a different session, it's OK */
 390     if (old_sid != my_sid)
 391         return 0;
 392
 393     r = query_dialog (_("Warning"),
 394                       _("GNU Midnight Commander is already\n"
 395                         "running on this terminal.\n"
 396                         "Subshell support will be disabled."), D_ERROR, 2, _("&OK"), _("&Quit"));
 397     if (r != 0)
 398     {
 399         return 2;
 400     }
 401
 402     return 1;
 403 }
 404
 405 /* --------------------------------------------------------------------------------------------- */
 406
 407 static void
 408 init_raw_mode ()
 409 {
 410     static int initialized = 0;
 411
 412     /* MC calls tty_reset_shell_mode() in pre_exec() to set the real tty to its */
 413     /* original settings.  However, here we need to make this tty very raw,     */
 414     /* so that all keyboard signals, XON/XOFF, etc. will get through to the     */
 415     /* pty.  So, instead of changing the code for execute(), pre_exec(),        */
 416     /* etc, we just set up the modes we need here, before each command.         */
 417
 418     if (initialized == 0)       /* First time: initialise 'raw_mode' */
 419     {
 420         tcgetattr (STDOUT_FILENO, &raw_mode);
 421         raw_mode.c_lflag &= ~ICANON;    /* Disable line-editing chars, etc.   */
 422         raw_mode.c_lflag &= ~ISIG;      /* Disable intr, quit & suspend chars */
 423         raw_mode.c_lflag &= ~ECHO;      /* Disable input echoing              */
 424         raw_mode.c_iflag &= ~IXON;      /* Pass ^S/^Q to subshell undisturbed */
 425         raw_mode.c_iflag &= ~ICRNL;     /* Don't translate CRs into LFs       */
 426         raw_mode.c_oflag &= ~OPOST;     /* Don't postprocess output           */
 427         raw_mode.c_cc[VTIME] = 0;       /* IE: wait forever, and return as    */
 428         raw_mode.c_cc[VMIN] = 1;        /* soon as a character is available   */
 429         initialized = 1;
 430     }
 431 }
 432
 433 /* --------------------------------------------------------------------------------------------- */
 434 /**
 435  * Wait until the subshell dies or stops.  If it stops, make it resume.
 436  * Possibly modifies the globals 'subshell_alive' and 'subshell_stopped'
 437  */
 438
 439 static void
 440 synchronize (void)
 441 {
 442     sigset_t sigchld_mask, old_mask;
 443
 444     sigemptyset (&sigchld_mask);
 445     sigaddset (&sigchld_mask, SIGCHLD);
 446     sigprocmask (SIG_BLOCK, &sigchld_mask, &old_mask);
 447
 448     /*
 449      * SIGCHLD should not be blocked, but we unblock it just in case.
 450      * This is known to be useful for cygwin 1.3.12 and older.
 451      */
 452     sigdelset (&old_mask, SIGCHLD);
 453
 454     /* Wait until the subshell has stopped */
 455     while (subshell_alive && !subshell_stopped)
 456         sigsuspend (&old_mask);
 457
 458     if (subshell_state != ACTIVE)
 459     {
 460         /* Discard all remaining data from stdin to the subshell */
 461         tcflush (subshell_pty_slave, TCIFLUSH);
 462     }
 463
 464     subshell_stopped = FALSE;
 465     kill (subshell_pid, SIGCONT);
 466
 467     sigprocmask (SIG_SETMASK, &old_mask, NULL);
 468     /* We can't do any better without modifying the shell(s) */
 469 }
 470
 471 /* --------------------------------------------------------------------------------------------- */
 472 /** Feed the subshell our keyboard input until it says it's finished */
 473
 474 static gboolean
 475 feed_subshell (int how, int fail_on_error)
 476 {
 477     fd_set read_set;            /* For 'select' */
 478     int maxfdp;
 479     int bytes;                  /* For the return value from 'read' */
 480     int i;                      /* Loop counter */
 481
 482     struct timeval wtime;       /* Maximum time we wait for the subshell */
 483     struct timeval *wptr;
 484
 485     /* we wait up to 10 seconds if fail_on_error, forever otherwise */
 486     wtime.tv_sec = 10;
 487     wtime.tv_usec = 0;
 488     wptr = fail_on_error ? &wtime : NULL;
 489
 490     while (TRUE)
 491     {
 492         if (!subshell_alive)
 493             return FALSE;
 494
 495         /* Prepare the file-descriptor set and call 'select' */
 496
 497         FD_ZERO (&read_set);
 498         FD_SET (mc_global.tty.subshell_pty, &read_set);
 499         FD_SET (subshell_pipe[READ], &read_set);
 500         maxfdp = max (mc_global.tty.subshell_pty, subshell_pipe[READ]);
 501         if (how == VISIBLY)
 502         {
 503             FD_SET (STDIN_FILENO, &read_set);
 504             maxfdp = max (maxfdp, STDIN_FILENO);
 505         }
 506
 507         if (select (maxfdp + 1, &read_set, NULL, NULL, wptr) == -1)
 508         {
 509             /* Despite using SA_RESTART, we still have to check for this */
 510             if (errno == EINTR)
 511             {
 512                 if (mc_global.tty.winch_flag != 0)
 513                     tty_change_screen_size ();
 514
 515                 continue;       /* try all over again */
 516             }
 517             tcsetattr (STDOUT_FILENO, TCSANOW, &shell_mode);
 518             fprintf (stderr, "select (FD_SETSIZE, &read_set...): %s\r\n",
 519                      unix_error_string (errno));
 520             exit (EXIT_FAILURE);
 521         }
 522
 523         if (FD_ISSET (mc_global.tty.subshell_pty, &read_set))
 524             /* Read from the subshell, write to stdout */
 525
 526             /* This loop improves performance by reducing context switches
 527                by a factor of 20 or so... unfortunately, it also hangs MC
 528                randomly, because of an apparent Linux bug.  Investigate. */
 529             /* for (i=0; i<5; ++i)  * FIXME -- experimental */
 530         {
 531             bytes = read (mc_global.tty.subshell_pty, pty_buffer, sizeof (pty_buffer));
 532
 533             /* The subshell has died */
 534             if (bytes == -1 && errno == EIO && !subshell_alive)
 535                 return FALSE;
 536
 537             if (bytes <= 0)
 538             {
 539                 tcsetattr (STDOUT_FILENO, TCSANOW, &shell_mode);
 540                 fprintf (stderr, "read (subshell_pty...): %s\r\n", unix_error_string (errno));
 541                 exit (EXIT_FAILURE);
 542             }
 543
 544             if (how == VISIBLY)
 545                 write_all (STDOUT_FILENO, pty_buffer, bytes);
 546         }
 547
 548         else if (FD_ISSET (subshell_pipe[READ], &read_set))
 549             /* Read the subshell's CWD and capture its prompt */
 550         {
 551             bytes = read (subshell_pipe[READ], subshell_cwd, MC_MAXPATHLEN + 1);
 552             if (bytes <= 0)
 553             {
 554                 tcsetattr (STDOUT_FILENO, TCSANOW, &shell_mode);
 555                 fprintf (stderr, "read (subshell_pipe[READ]...): %s\r\n",
 556                          unix_error_string (errno));
 557                 exit (EXIT_FAILURE);
 558             }
 559
 560             subshell_cwd[bytes - 1] = 0;        /* Squash the final '\n' */
 561
 562             synchronize ();
 563
 564             subshell_ready = TRUE;
 565             if (subshell_state == RUNNING_COMMAND)
 566             {
 567                 subshell_state = INACTIVE;
 568                 return TRUE;
 569             }
 570         }
 571
 572         else if (FD_ISSET (STDIN_FILENO, &read_set))
 573             /* Read from stdin, write to the subshell */
 574         {
 575             bytes = read (STDIN_FILENO, pty_buffer, sizeof (pty_buffer));
 576             if (bytes <= 0)
 577             {
 578                 tcsetattr (STDOUT_FILENO, TCSANOW, &shell_mode);
 579                 fprintf (stderr,
 580                          "read (STDIN_FILENO, pty_buffer...): %s\r\n", unix_error_string (errno));
 581                 exit (EXIT_FAILURE);
 582             }
 583
 584             for (i = 0; i < bytes; ++i)
 585                 if (pty_buffer[i] == subshell_switch_key)
 586                 {
 587                     write_all (mc_global.tty.subshell_pty, pty_buffer, i);
 588                     if (subshell_ready)
 589                         subshell_state = INACTIVE;
 590                     return TRUE;
 591                 }
 592
 593             write_all (mc_global.tty.subshell_pty, pty_buffer, bytes);
 594
 595             if (pty_buffer[bytes - 1] == '\n' || pty_buffer[bytes - 1] == '\r')
 596                 subshell_ready = FALSE;
 597         }
 598         else
 599             return FALSE;
 600     }
 601 }
 602
 603 /* --------------------------------------------------------------------------------------------- */
 604 /* pty opening functions */
 605
 606 #ifdef HAVE_GRANTPT
 607
 608 /* System V version of pty_open_master */
 609
 610 static int
 611 pty_open_master (char *pty_name)
 612 {
 613     char *slave_name;
 614     int pty_master;
 615
 616 #ifdef HAVE_POSIX_OPENPT
 617     pty_master = posix_openpt (O_RDWR);
 618 #elif HAVE_GETPT
 619     /* getpt () is a GNU extension (glibc 2.1.x) */
 620     pty_master = getpt ();
 621 #elif IS_AIX
 622     strcpy (pty_name, "/dev/ptc");
 623     pty_master = open (pty_name, O_RDWR);
 624 #else
 625     strcpy (pty_name, "/dev/ptmx");
 626     pty_master = open (pty_name, O_RDWR);
 627 #endif
 628
 629     if (pty_master == -1)
 630         return -1;
 631
 632     if (grantpt (pty_master) == -1      /* Grant access to slave */
 633         || unlockpt (pty_master) == -1  /* Clear slave's lock flag */
 634         || !(slave_name = ptsname (pty_master)))        /* Get slave's name */
 635     {
 636         close (pty_master);
 637         return -1;
 638     }
 639     strcpy (pty_name, slave_name);
 640     return pty_master;
 641 }
 642
 643 /* --------------------------------------------------------------------------------------------- */
 644 /** System V version of pty_open_slave */
 645
 646 static int
 647 pty_open_slave (const char *pty_name)
 648 {
 649     int pty_slave = open (pty_name, O_RDWR);
 650
 651     if (pty_slave == -1)
 652     {
 653         fprintf (stderr, "open (%s, O_RDWR): %s\r\n", pty_name, unix_error_string (errno));
 654         return -1;
 655     }
 656 #if !defined(__osf__) && !defined(__linux__)
 657 #if defined (I_FIND) && defined (I_PUSH)
 658     if (!ioctl (pty_slave, I_FIND, "ptem"))
 659         if (ioctl (pty_slave, I_PUSH, "ptem") == -1)
 660         {
 661             fprintf (stderr, "ioctl (%d, I_PUSH, \"ptem\") failed: %s\r\n",
 662                      pty_slave, unix_error_string (errno));
 663             close (pty_slave);
 664             return -1;
 665         }
 666
 667     if (!ioctl (pty_slave, I_FIND, "ldterm"))
 668         if (ioctl (pty_slave, I_PUSH, "ldterm") == -1)
 669         {
 670             fprintf (stderr,
 671                      "ioctl (%d, I_PUSH, \"ldterm\") failed: %s\r\n",
 672                      pty_slave, unix_error_string (errno));
 673             close (pty_slave);
 674             return -1;
 675         }
 676 #if !defined(sgi) && !defined(__sgi)
 677     if (!ioctl (pty_slave, I_FIND, "ttcompat"))
 678         if (ioctl (pty_slave, I_PUSH, "ttcompat") == -1)
 679         {
 680             fprintf (stderr,
 681                      "ioctl (%d, I_PUSH, \"ttcompat\") failed: %s\r\n",
 682                      pty_slave, unix_error_string (errno));
 683             close (pty_slave);
 684             return -1;
 685         }
 686 #endif /* sgi || __sgi */
 687 #endif /* I_FIND && I_PUSH */
 688 #endif /* __osf__ || __linux__ */
 689
 690     fcntl (pty_slave, F_SETFD, FD_CLOEXEC);
 691     return pty_slave;
 692 }
 693
 694 #else /* !HAVE_GRANTPT */
 695
 696 /* --------------------------------------------------------------------------------------------- */
 697 /** BSD version of pty_open_master */
 698 static int
 699 pty_open_master (char *pty_name)
 700 {
 701     int pty_master;
 702     const char *ptr1, *ptr2;
 703
 704     strcpy (pty_name, "/dev/ptyXX");
 705     for (ptr1 = "pqrstuvwxyzPQRST"; *ptr1; ++ptr1)
 706     {
 707         pty_name[8] = *ptr1;
 708         for (ptr2 = "0123456789abcdef"; *ptr2 != '\0'; ++ptr2)
 709         {
 710             pty_name[9] = *ptr2;
 711
 712             /* Try to open master */
 713             pty_master = open (pty_name, O_RDWR);
 714             if (pty_master == -1)
 715             {
 716                 if (errno == ENOENT)    /* Different from EIO */
 717                     return -1;  /* Out of pty devices */
 718                 continue;       /* Try next pty device */
 719             }
 720             pty_name[5] = 't';  /* Change "pty" to "tty" */
 721             if (access (pty_name, 6) != 0)
 722             {
 723                 close (pty_master);
 724                 pty_name[5] = 'p';
 725                 continue;
 726             }
 727             return pty_master;
 728         }
 729     }
 730     return -1;                  /* Ran out of pty devices */
 731 }
 732
 733 /* --------------------------------------------------------------------------------------------- */
 734 /** BSD version of pty_open_slave */
 735
 736 static int
 737 pty_open_slave (const char *pty_name)
 738 {
 739     int pty_slave;
 740     struct group *group_info = getgrnam ("tty");
 741
 742     if (group_info != NULL)
 743     {
 744         /* The following two calls will only succeed if we are root */
 745         /* [Commented out while permissions problem is investigated] */
 746         /* chown (pty_name, getuid (), group_info->gr_gid);  FIXME */
 747         /* chmod (pty_name, S_IRUSR | S_IWUSR | S_IWGRP);   FIXME */
 748     }
 749     pty_slave = open (pty_name, O_RDWR);
 750     if (pty_slave == -1)
 751         fprintf (stderr, "open (pty_name, O_RDWR): %s\r\n", pty_name);
 752     fcntl (pty_slave, F_SETFD, FD_CLOEXEC);
 753     return pty_slave;
 754 }
 755 #endif /* !HAVE_GRANTPT */
 756
 757 /* --------------------------------------------------------------------------------------------- */
 758 /*** public functions ****************************************************************************/
 759 /* --------------------------------------------------------------------------------------------- */
 760
 761 /* --------------------------------------------------------------------------------------------- */
 762 /**
 763  *  Fork the subshell, and set up many, many things.
 764  *
 765  *  Possibly modifies the global variables:
 766  *      subshell_type, subshell_alive, subshell_stopped, subshell_pid
 767  *      mc_global.tty.use_subshell - Is set to FALSE if we can't run the subshell
 768  *      quit - Can be set to SUBSHELL_EXIT by the SIGCHLD handler
 769  */
 770
 771 void
 772 init_subshell (void)
 773 {
 774     /* This must be remembered across calls to init_subshell() */
 775     static char pty_name[BUF_SMALL];
 776     char precmd[BUF_SMALL];
 777
 778     switch (check_sid ())
 779     {
 780     case 1:
 781         mc_global.tty.use_subshell = FALSE;
 782         return;
 783     case 2:
 784         mc_global.tty.use_subshell = FALSE;
 785         mc_global.midnight_shutdown = TRUE;
 786         return;
 787     }
 788
 789     /* Take the current (hopefully pristine) tty mode and make */
 790     /* a raw mode based on it now, before we do anything else with it */
 791     init_raw_mode ();
 792
 793     if (mc_global.tty.subshell_pty == 0)
 794     {                           /* First time through */
 795         /* Find out what type of shell we have */
 796
 797         if (strstr (mc_global.tty.shell, "/zsh") || getenv ("ZSH_VERSION"))
 798             subshell_type = ZSH;
 799         else if (strstr (mc_global.tty.shell, "/tcsh"))
 800             subshell_type = TCSH;
 801         else if (strstr (mc_global.tty.shell, "/csh"))
 802             subshell_type = TCSH;
 803         else if (strstr (mc_global.tty.shell, "/bash") || getenv ("BASH"))
 804             subshell_type = BASH;
 805         else if (strstr (mc_global.tty.shell, "/fish"))
 806             subshell_type = FISH;
 807         else
 808         {
 809             mc_global.tty.use_subshell = FALSE;
 810             return;
 811         }
 812
 813         /* Open a pty for talking to the subshell */
 814
 815         /* FIXME: We may need to open a fresh pty each time on SVR4 */
 816
 817         mc_global.tty.subshell_pty = pty_open_master (pty_name);
 818         if (mc_global.tty.subshell_pty == -1)
 819         {
 820             fprintf (stderr, "Cannot open master side of pty: %s\r\n", unix_error_string (errno));
 821             mc_global.tty.use_subshell = FALSE;
 822             return;
 823         }
 824         subshell_pty_slave = pty_open_slave (pty_name);
 825         if (subshell_pty_slave == -1)
 826         {
 827             fprintf (stderr, "Cannot open slave side of pty %s: %s\r\n",
 828                      pty_name, unix_error_string (errno));
 829             mc_global.tty.use_subshell = FALSE;
 830             return;
 831         }
 832
 833         /* Create a pipe for receiving the subshell's CWD */
 834
 835         if (subshell_type == TCSH)
 836         {
 837             g_snprintf (tcsh_fifo, sizeof (tcsh_fifo), "%s/mc.pipe.%d",
 838                         mc_tmpdir (), (int) getpid ());
 839             if (mkfifo (tcsh_fifo, 0600) == -1)
 840             {
 841                 fprintf (stderr, "mkfifo(%s) failed: %s\r\n", tcsh_fifo, unix_error_string (errno));
 842                 mc_global.tty.use_subshell = FALSE;
 843                 return;
 844             }
 845
 846             /* Opening the FIFO as O_RDONLY or O_WRONLY causes deadlock */
 847
 848             if ((subshell_pipe[READ] = open (tcsh_fifo, O_RDWR)) == -1
 849                 || (subshell_pipe[WRITE] = open (tcsh_fifo, O_RDWR)) == -1)
 850             {
 851                 fprintf (stderr, _("Cannot open named pipe %s\n"), tcsh_fifo);
 852                 perror (__FILE__ ": open");
 853                 mc_global.tty.use_subshell = FALSE;
 854                 return;
 855             }
 856         }
 857         else /* subshell_type is BASH or ZSH */ if (pipe (subshell_pipe))
 858         {
 859             perror (__FILE__ ": couldn't create pipe");
 860             mc_global.tty.use_subshell = FALSE;
 861             return;
 862         }
 863     }
 864
 865     /* Fork the subshell */
 866
 867     subshell_alive = TRUE;
 868     subshell_stopped = FALSE;
 869     subshell_pid = fork ();
 870
 871     if (subshell_pid == -1)
 872     {
 873         fprintf (stderr, "Cannot spawn the subshell process: %s\r\n", unix_error_string (errno));
 874         /* We exit here because, if the process table is full, the */
 875         /* other method of running user commands won't work either */
 876         exit (EXIT_FAILURE);
 877     }
 878
 879     if (subshell_pid == 0)
 880     {
 881         /* We are in the child process */
 882         init_subshell_child (pty_name);
 883     }
 884
 885     /* Set up 'precmd' or equivalent for reading the subshell's CWD */
 886
 887     switch (subshell_type)
 888     {
 889     case BASH:
 890         g_snprintf (precmd, sizeof (precmd),
 891                     " PROMPT_COMMAND='pwd>&%d;kill -STOP $$'\n", subshell_pipe[WRITE]);
 892         break;
 893
 894     case ZSH:
 895         g_snprintf (precmd, sizeof (precmd),
 896                     " precmd(){ pwd>&%d;kill -STOP $$ }\n", subshell_pipe[WRITE]);
 897         break;
 898
 899     case TCSH:
 900         g_snprintf (precmd, sizeof (precmd),
 901                     "set echo_style=both;"
 902                     "alias precmd 'echo $cwd:q >>%s;kill -STOP $$'\n", tcsh_fifo);
 903         break;
 904     case FISH:
 905         g_snprintf (precmd, sizeof (precmd),
 906                     "function fish_prompt ; pwd>&%d;kill -STOP %%self; end\n",
 907                     subshell_pipe[WRITE]);
 908         break;
 909
 910     }
 911     write_all (mc_global.tty.subshell_pty, precmd, strlen (precmd));
 912
 913     /* Wait until the subshell has started up and processed the command */
 914
 915     subshell_state = RUNNING_COMMAND;
 916     tty_enable_interrupt_key ();
 917     if (!feed_subshell (QUIETLY, TRUE))
 918     {
 919         mc_global.tty.use_subshell = FALSE;
 920     }
 921     tty_disable_interrupt_key ();
 922     if (!subshell_alive)
 923         mc_global.tty.use_subshell = FALSE;     /* Subshell died instantly, so don't use it */
 924 }
 925
 926 /* --------------------------------------------------------------------------------------------- */
 927
 928 int
 929 invoke_subshell (const char *command, int how, vfs_path_t ** new_dir_vpath)
 930 {
 931     char *pcwd;
 932
 933     /* Make the MC terminal transparent */
 934     tcsetattr (STDOUT_FILENO, TCSANOW, &raw_mode);
 935
 936     /* Make the subshell change to MC's working directory */
 937     if (new_dir_vpath != NULL)
 938         do_subshell_chdir (current_panel->cwd_vpath, TRUE, TRUE);
 939
 940     if (command == NULL)        /* The user has done "C-o" from MC */
 941     {
 942         if (subshell_state == INACTIVE)
 943         {
 944             subshell_state = ACTIVE;
 945             /* FIXME: possibly take out this hack; the user can
 946                re-play it by hitting C-hyphen a few times! */
 947             if (subshell_ready)
 948                 write_all (mc_global.tty.subshell_pty, " \b", 2);       /* Hack to make prompt reappear */
 949         }
 950     }
 951     else                        /* MC has passed us a user command */
 952     {
 953         if (how == QUIETLY)
 954             write_all (mc_global.tty.subshell_pty, " ", 1);
 955         /* FIXME: if command is long (>8KB ?) we go comma */
 956         write_all (mc_global.tty.subshell_pty, command, strlen (command));
 957         write_all (mc_global.tty.subshell_pty, "\n", 1);
 958         subshell_state = RUNNING_COMMAND;
 959         subshell_ready = FALSE;
 960     }
 961
 962     feed_subshell (how, FALSE);
 963
 964     pcwd = vfs_translate_path_n (vfs_path_as_str (current_panel->cwd_vpath));
 965
 966     if (new_dir_vpath != NULL && subshell_alive && strcmp (subshell_cwd, pcwd))
 967         *new_dir_vpath = vfs_path_from_str (subshell_cwd);      /* Make MC change to the subshell's CWD */
 968     g_free (pcwd);
 969
 970     /* Restart the subshell if it has died by SIGHUP, SIGQUIT, etc. */
 971     while (!subshell_alive && quit == 0 && mc_global.tty.use_subshell)
 972         init_subshell ();
 973
 974     prompt_pos = 0;
 975
 976     return quit;
 977 }
 978
 979
 980 /* --------------------------------------------------------------------------------------------- */
 981
 982 gboolean
 983 read_subshell_prompt (void)
 984 {
 985     int rc = 0;
 986     ssize_t bytes = 0;
 987     struct timeval timeleft = { 0, 0 };
 988     GString *p;
 989     gboolean prompt_was_reset = FALSE;
 990
 991     fd_set tmp;
 992     FD_ZERO (&tmp);
 993     FD_SET (mc_global.tty.subshell_pty, &tmp);
 994
 995     /* First time through */
 996     if (subshell_prompt == NULL)
 997         subshell_prompt = g_string_sized_new (INITIAL_PROMPT_SIZE);
 998
 999     p = g_string_sized_new (INITIAL_PROMPT_SIZE);
1000
1001     while (subshell_alive
1002            && (rc = select (mc_global.tty.subshell_pty + 1, &tmp, NULL, NULL, &timeleft)) != 0)
1003     {
1004         ssize_t i;
1005
1006         /* Check for 'select' errors */
1007         if (rc == -1)
1008         {
1009             if (errno == EINTR)
1010             {
1011                 if (mc_global.tty.winch_flag != 0)
1012                     tty_change_screen_size ();
1013
1014                 continue;
1015             }
1016
1017             fprintf (stderr, "select (FD_SETSIZE, &tmp...): %s\r\n", unix_error_string (errno));
1018             exit (EXIT_FAILURE);
1019         }
1020
1021         bytes = read (mc_global.tty.subshell_pty, pty_buffer, sizeof (pty_buffer));
1022
1023         /* Extract the prompt from the shell output */
1024         for (i = 0; i < bytes; i++)
1025             if (pty_buffer[i] == '\n' || pty_buffer[i] == '\r')
1026             {
1027                 g_string_set_size (p, 0);
1028                 prompt_was_reset = TRUE;
1029             }
1030             else if (pty_buffer[i] != '\0')
1031                 g_string_append_c (p, pty_buffer[i]);
1032     }
1033
1034     if (p->len != 0 || prompt_was_reset)
1035         g_string_assign (subshell_prompt, p->str);
1036
1037     g_string_free (p, TRUE);
1038
1039     return (rc != 0 || bytes != 0);
1040 }
1041
1042 /* --------------------------------------------------------------------------------------------- */
1043
1044 void
1045 do_update_prompt (void)
1046 {
1047     if (update_subshell_prompt)
1048     {
1049         printf ("\r\n%s", subshell_prompt->str);
1050         fflush (stdout);
1051         update_subshell_prompt = FALSE;
1052     }
1053 }
1054
1055 /* --------------------------------------------------------------------------------------------- */
1056
1057 gboolean
1058 exit_subshell (void)
1059 {
1060     gboolean subshell_quit = TRUE;
1061
1062     if (subshell_state != INACTIVE && subshell_alive)
1063         subshell_quit =
1064             query_dialog (_("Warning"),
1065                           _("The shell is still active. Quit anyway?"),
1066                           D_NORMAL, 2, _("&Yes"), _("&No")) == 0;
1067
1068     if (subshell_quit)
1069     {
1070         if (subshell_type == TCSH)
1071         {
1072             if (unlink (tcsh_fifo) == -1)
1073                 fprintf (stderr, "Cannot remove named pipe %s: %s\r\n",
1074                          tcsh_fifo, unix_error_string (errno));
1075         }
1076
1077         g_string_free (subshell_prompt, TRUE);
1078         subshell_prompt = NULL;
1079         pty_buffer[0] = '\0';
1080     }
1081
1082     return subshell_quit;
1083 }
1084
1085 /* --------------------------------------------------------------------------------------------- */
1086 /**
1087  * Carefully quote directory name to allow entering any directory safely,
1088  * no matter what weird characters it may contain in its name.
1089  * NOTE: Treat directory name an untrusted data, don't allow it to cause
1090  * executing any commands in the shell.  Escape all control characters.
1091  * Use following technique:
1092  *
1093  * printf(1) with format string containing a single conversion specifier,
1094  * "b", and an argument which contains a copy of the string passed to
1095  * subshell_name_quote() with all characters, except digits and letters,
1096  * replaced by the backslash-escape sequence \0nnn, where "nnn" is the
1097  * numeric value of the character converted to octal number.
1098  *
1099  *   cd "`printf "%b" 'ABC\0nnnDEF\0nnnXYZ'`"
1100  *
1101  */
1102
1103 static GString *
1104 subshell_name_quote (const char *s)
1105 {
1106     GString *ret;
1107     const char *su, *n;
1108     const char *quote_cmd_start, *quote_cmd_end;
1109
1110     if (subshell_type == FISH)
1111     {
1112         quote_cmd_start = "(printf \"%b\" '";
1113         quote_cmd_end = "')";
1114     }
1115     else
1116     {
1117         quote_cmd_start = "\"`printf \"%b\" '";
1118         quote_cmd_end = "'`\"";
1119     }
1120
1121     ret = g_string_sized_new (64);
1122
1123     /* Prevent interpreting leading '-' as a switch for 'cd' */
1124     if (s[0] == '-')
1125         g_string_append (ret, "./");
1126
1127     /* Copy the beginning of the command to the buffer */
1128     g_string_append (ret, quote_cmd_start);
1129
1130     /*
1131      * Print every character except digits and letters as a backslash-escape
1132      * sequence of the form \0nnn, where "nnn" is the numeric value of the
1133      * character converted to octal number.
1134      */
1135     for (su = s; su[0] != '\0'; su = n)
1136     {
1137         n = str_cget_next_char_safe (su);
1138
1139         if (str_isalnum (su))
1140             g_string_append_len (ret, su, n - su);
1141         else
1142         {
1143             int c;
1144
1145             for (c = 0; c < n - su; c++)
1146                 g_string_append_printf (ret, "\\0%03o", (unsigned char) su[c]);
1147         }
1148     }
1149
1150     g_string_append (ret, quote_cmd_end);
1151
1152     return ret;
1153 }
1154
1155
1156 /* --------------------------------------------------------------------------------------------- */
1157
1158 /** If it actually changed the directory it returns true */
1159 void
1160 do_subshell_chdir (const vfs_path_t * vpath, gboolean update_prompt, gboolean reset_prompt)
1161 {
1162     char *pcwd;
1163
1164     pcwd = vfs_path_to_str_flags (current_panel->cwd_vpath, 0, VPF_RECODE);
1165
1166     if (!(subshell_state == INACTIVE && strcmp (subshell_cwd, pcwd) != 0))
1167     {
1168         /* We have to repaint the subshell prompt if we read it from
1169          * the main program.  Please note that in the code after this
1170          * if, the cd command that is sent will make the subshell
1171          * repaint the prompt, so we don't have to paint it. */
1172         if (update_prompt)
1173             do_update_prompt ();
1174         g_free (pcwd);
1175         return;
1176     }
1177
1178     /* The initial space keeps this out of the command history (in bash
1179        because we set "HISTCONTROL=ignorespace") */
1180     write_all (mc_global.tty.subshell_pty, " cd ", 4);
1181
1182     if (vpath != NULL)
1183     {
1184         char *translate;
1185
1186         translate = vfs_translate_path_n (vfs_path_as_str (vpath));
1187         if (translate != NULL)
1188         {
1189             GString *temp;
1190
1191             temp = subshell_name_quote (translate);
1192             write_all (mc_global.tty.subshell_pty, temp->str, temp->len);
1193             g_string_free (temp, TRUE);
1194
1195             g_free (translate);
1196         }
1197         else
1198         {
1199             write_all (mc_global.tty.subshell_pty, ".", 1);
1200         }
1201     }
1202     else
1203     {
1204         write_all (mc_global.tty.subshell_pty, "/", 1);
1205     }
1206     write_all (mc_global.tty.subshell_pty, "\n", 1);
1207
1208     subshell_state = RUNNING_COMMAND;
1209     feed_subshell (QUIETLY, FALSE);
1210
1211     if (subshell_alive)
1212     {
1213         int bPathNotEq = strcmp (subshell_cwd, pcwd);
1214
1215         if (bPathNotEq && subshell_type == TCSH)
1216         {
1217             char rp_subshell_cwd[PATH_MAX];
1218             char rp_current_panel_cwd[PATH_MAX];
1219
1220             char *p_subshell_cwd = mc_realpath (subshell_cwd, rp_subshell_cwd);
1221             char *p_current_panel_cwd = mc_realpath (pcwd, rp_current_panel_cwd);
1222
1223             if (p_subshell_cwd == NULL)
1224                 p_subshell_cwd = subshell_cwd;
1225             if (p_current_panel_cwd == NULL)
1226                 p_current_panel_cwd = pcwd;
1227             bPathNotEq = strcmp (p_subshell_cwd, p_current_panel_cwd);
1228         }
1229
1230         if (bPathNotEq && strcmp (pcwd, ".") != 0)
1231         {
1232             char *cwd;
1233
1234             cwd = vfs_path_to_str_flags (current_panel->cwd_vpath, 0, VPF_STRIP_PASSWORD);
1235             vfs_print_message (_("Warning: Cannot change to %s.\n"), cwd);
1236             g_free (cwd);
1237         }
1238     }
1239
1240     if (reset_prompt)
1241         prompt_pos = 0;
1242     update_subshell_prompt = FALSE;
1243
1244     g_free (pcwd);
1245     /* Make sure that MC never stores the CWD in a silly format */
1246     /* like /usr////lib/../bin, or the strcmp() above will fail */
1247 }
1248
1249 /* --------------------------------------------------------------------------------------------- */
1250
1251 void
1252 subshell_get_console_attributes (void)
1253 {
1254     /* Get our current terminal modes */
1255
1256     if (tcgetattr (STDOUT_FILENO, &shell_mode))
1257     {
1258         fprintf (stderr, "Cannot get terminal settings: %s\r\n", unix_error_string (errno));
1259         mc_global.tty.use_subshell = FALSE;
1260     }
1261 }
1262
1263 /* --------------------------------------------------------------------------------------------- */
1264 /**
1265  * Figure out whether the subshell has stopped, exited or been killed
1266  * Possibly modifies: 'subshell_alive', 'subshell_stopped' and 'quit' */
1267
1268 void
1269 sigchld_handler (int sig)
1270 {
1271     int status;
1272     pid_t pid;
1273
1274     (void) sig;
1275
1276     pid = waitpid (subshell_pid, &status, WUNTRACED | WNOHANG);
1277
1278     if (pid == subshell_pid)
1279     {
1280         /* Figure out what has happened to the subshell */
1281
1282         if (WIFSTOPPED (status))
1283         {
1284             if (WSTOPSIG (status) == SIGSTOP)
1285             {
1286                 /* The subshell has received a SIGSTOP signal */
1287                 subshell_stopped = TRUE;
1288             }
1289             else
1290             {
1291                 /* The user has suspended the subshell.  Revive it */
1292                 kill (subshell_pid, SIGCONT);
1293             }
1294         }
1295         else
1296         {
1297             /* The subshell has either exited normally or been killed */
1298             subshell_alive = FALSE;
1299             delete_select_channel (mc_global.tty.subshell_pty);
1300             if (WIFEXITED (status) && WEXITSTATUS (status) != FORK_FAILURE)
1301                 quit |= SUBSHELL_EXIT;  /* Exited normally */
1302         }
1303     }
1304 #ifdef __linux__
1305     pid = waitpid (cons_saver_pid, &status, WUNTRACED | WNOHANG);
1306
1307     if (pid == cons_saver_pid)
1308     {
1309
1310         if (WIFSTOPPED (status))
1311             /* Someone has stopped cons.saver - restart it */
1312             kill (pid, SIGCONT);
1313         else
1314         {
1315             /* cons.saver has died - disable confole saving */
1316             handle_console (CONSOLE_DONE);
1317             mc_global.tty.console_flag = '\0';
1318         }
1319
1320     }
1321 #endif /* __linux__ */
1322
1323     /* If we got here, some other child exited; ignore it */
1324 }
1325
1326 /* --------------------------------------------------------------------------------------------- */