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