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