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 #ifdef HAVE_SUBSHELL_SUPPORT
  31
  32 #ifndef _GNU_SOURCE
  33 #define _GNU_SOURCE 1
  34 #endif
  35
  36 #include <ctype.h>
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <errno.h>
  40 #include <string.h>
  41 #include <signal.h>
  42 #include <fcntl.h>
  43 #include <sys/types.h>
  44 #include <sys/wait.h>
  45 #ifdef HAVE_SYS_IOCTL_H
  46 #include <sys/ioctl.h>
  47 #endif
  48 #include <termios.h>
  49 #include <unistd.h>
  50
  51 #ifdef HAVE_STROPTS_H
  52 #include <stropts.h>            /* For I_PUSH */
  53 #endif /* HAVE_STROPTS_H */
  54
  55 #include "lib/global.h"
  56
  57 #include "lib/tty/tty.h"        /* LINES */
  58 #include "lib/tty/key.h"        /* XCTRL */
  59 #include "lib/vfs/vfs.h"
  60 #include "lib/strutil.h"
  61 #include "lib/mcconfig.h"
  62 #include "lib/util.h"
  63 #include "lib/widget.h"
  64
  65 #include "filemanager/midnight.h"       /* current_panel */
  66
  67 #include "consaver/cons.saver.h"        /* handle_console() */
  68 #include "subshell.h"
  69
  70 /*** global variables ****************************************************************************/
  71
  72 /* State of the subshell:
  73  * INACTIVE: the default state; awaiting a command
  74  * ACTIVE: remain in the shell until the user hits `subshell_switch_key'
  75  * RUNNING_COMMAND: return to MC when the current command finishes */
  76 enum subshell_state_enum subshell_state;
  77
  78 /* Holds the latest prompt captured from the subshell */
  79 char *subshell_prompt = NULL;
  80
  81 /* Subshell: if set, then the prompt was not saved on CONSOLE_SAVE */
  82 /* We need to paint it after CONSOLE_RESTORE, see: load_prompt */
  83 gboolean update_subshell_prompt = FALSE;
  84
  85 /*** file scope macro definitions ****************************************************************/
  86
  87 #ifndef WEXITSTATUS
  88 #define WEXITSTATUS(stat_val) ((unsigned)(stat_val) >> 8)
  89 #endif
  90
  91 #ifndef WIFEXITED
  92 #define WIFEXITED(stat_val) (((stat_val) & 255) == 0)
  93 #endif
  94
  95 #ifndef STDIN_FILENO
  96 #define STDIN_FILENO 0
  97 #endif
  98
  99 #ifndef STDOUT_FILENO
 100 #define STDOUT_FILENO 1
 101 #endif
 102
 103 #ifndef STDERR_FILENO
 104 #define STDERR_FILENO 2
 105 #endif
 106
 107 /* Initial length of the buffer for the subshell's prompt */
 108 #define INITIAL_PROMPT_SIZE 10
 109
 110 /* Used by the child process to indicate failure to start the subshell */
 111 #define FORK_FAILURE 69         /* Arbitrary */
 112
 113 /* Length of the buffer for all I/O with the subshell */
 114 #define PTY_BUFFER_SIZE BUF_SMALL       /* Arbitrary; but keep it >= 80 */
 115
 116 /*** file scope type declarations ****************************************************************/
 117
 118 /* For pipes */
 119 enum
 120 {
 121     READ = 0,
 122     WRITE = 1
 123 };
 124
 125 /* Subshell type (gleaned from the SHELL environment variable, if available) */
 126 static enum
 127 {
 128     BASH,
 129     TCSH,
 130     ZSH,
 131     FISH
 132 } subshell_type;
 133
 134 /*** file scope variables ************************************************************************/
 135
 136 /* tcsh closes all non-standard file descriptors, so we have to use a pipe */
 137 static char tcsh_fifo[128];
 138
 139 static int subshell_pty_slave = -1;
 140
 141 /* The key for switching back to MC from the subshell */
 142 /* *INDENT-OFF* */
 143 static const char subshell_switch_key = XCTRL ('o') & 255;
 144 /* *INDENT-ON* */
 145
 146 /* For reading/writing on the subshell's pty */
 147 static char pty_buffer[PTY_BUFFER_SIZE] = "\0";
 148
 149 /* To pass CWD info from the subshell to MC */
 150 static int subshell_pipe[2];
 151
 152 /* The subshell's process ID */
 153 static pid_t subshell_pid = 1;
 154
 155 /* One extra char for final '\n' */
 156 static char subshell_cwd[MC_MAXPATHLEN + 1];
 157
 158 /* Flag to indicate whether the subshell is ready for next command */
 159 static int subshell_ready;
 160
 161 /* The following two flags can be changed by the SIGCHLD handler. This is */
 162 /* OK, because the `int' type is updated atomically on all known machines */
 163 static volatile int subshell_alive, subshell_stopped;
 164
 165 /* We store the terminal's initial mode here so that we can configure
 166    the pty similarly, and also so we can restore the real terminal to
 167    sanity if we have to exit abruptly */
 168 static struct termios shell_mode;
 169
 170 /* This is a transparent mode for the terminal where MC is running on */
 171 /* It is used when the shell is active, so that the control signals */
 172 /* are delivered to the shell pty */
 173 static struct termios raw_mode;
 174
 175 /* This counter indicates how many characters of prompt we have read */
 176 /* FIXME: try to figure out why this had to become global */
 177 static int prompt_pos;
 178
 179
 180 /*** file scope functions ************************************************************************/
 181 /* --------------------------------------------------------------------------------------------- */
 182 /**
 183  *  Write all data, even if the write() call is interrupted.
 184  */
 185
 186 static ssize_t
 187 write_all (int fd, const void *buf, size_t count)
 188 {
 189     ssize_t ret;
 190     ssize_t written = 0;
 191     while (count > 0)
 192     {
 193         ret = write (fd, (const unsigned char *) buf + written, count);
 194         if (ret < 0)
 195         {
 196             if (errno == EINTR)
 197             {
 198                 continue;
 199             }
 200             else
 201             {
 202                 return written > 0 ? written : ret;
 203             }
 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     }
 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         _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 (shell, "bash", "-rcfile", init_file, (char *) NULL);
 333         break;
 334
 335     case TCSH:
 336         execl (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 (shell, "zsh", "-Z", "-g", (char *) NULL);
 343
 344         break;
 345
 346     case FISH:
 347         execl (shell, "fish", (char *) NULL);
 348         break;
 349     }
 350
 351     /* If we get this far, everything failed miserably */
 352     g_free (init_file);
 353     _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
 506             /* Despite using SA_RESTART, we still have to check for this */
 507             if (errno == EINTR)
 508                 continue;       /* try all over again */
 509             tcsetattr (STDOUT_FILENO, TCSANOW, &shell_mode);
 510             fprintf (stderr, "select (FD_SETSIZE, &read_set...): %s\r\n",
 511                      unix_error_string (errno));
 512             exit (EXIT_FAILURE);
 513         }
 514
 515         if (FD_ISSET (mc_global.tty.subshell_pty, &read_set))
 516             /* Read from the subshell, write to stdout */
 517
 518             /* This loop improves performance by reducing context switches
 519                by a factor of 20 or so... unfortunately, it also hangs MC
 520                randomly, because of an apparent Linux bug.  Investigate. */
 521             /* for (i=0; i<5; ++i)  * FIXME -- experimental */
 522         {
 523             bytes = read (mc_global.tty.subshell_pty, pty_buffer, sizeof (pty_buffer));
 524
 525             /* The subshell has died */
 526             if (bytes == -1 && errno == EIO && !subshell_alive)
 527                 return FALSE;
 528
 529             if (bytes <= 0)
 530             {
 531                 tcsetattr (STDOUT_FILENO, TCSANOW, &shell_mode);
 532                 fprintf (stderr, "read (subshell_pty...): %s\r\n", unix_error_string (errno));
 533                 exit (EXIT_FAILURE);
 534             }
 535
 536             if (how == VISIBLY)
 537                 write_all (STDOUT_FILENO, pty_buffer, bytes);
 538         }
 539
 540         else if (FD_ISSET (subshell_pipe[READ], &read_set))
 541             /* Read the subshell's CWD and capture its prompt */
 542         {
 543             bytes = read (subshell_pipe[READ], subshell_cwd, MC_MAXPATHLEN + 1);
 544             if (bytes <= 0)
 545             {
 546                 tcsetattr (STDOUT_FILENO, TCSANOW, &shell_mode);
 547                 fprintf (stderr, "read (subshell_pipe[READ]...): %s\r\n",
 548                          unix_error_string (errno));
 549                 exit (EXIT_FAILURE);
 550             }
 551
 552             subshell_cwd[bytes - 1] = 0;        /* Squash the final '\n' */
 553
 554             synchronize ();
 555
 556             subshell_ready = TRUE;
 557             if (subshell_state == RUNNING_COMMAND)
 558             {
 559                 subshell_state = INACTIVE;
 560                 return TRUE;
 561             }
 562         }
 563
 564         else if (FD_ISSET (STDIN_FILENO, &read_set))
 565             /* Read from stdin, write to the subshell */
 566         {
 567             bytes = read (STDIN_FILENO, pty_buffer, sizeof (pty_buffer));
 568             if (bytes <= 0)
 569             {
 570                 tcsetattr (STDOUT_FILENO, TCSANOW, &shell_mode);
 571                 fprintf (stderr,
 572                          "read (STDIN_FILENO, pty_buffer...): %s\r\n", unix_error_string (errno));
 573                 exit (EXIT_FAILURE);
 574             }
 575
 576             for (i = 0; i < bytes; ++i)
 577                 if (pty_buffer[i] == subshell_switch_key)
 578                 {
 579                     write_all (mc_global.tty.subshell_pty, pty_buffer, i);
 580                     if (subshell_ready)
 581                         subshell_state = INACTIVE;
 582                     return TRUE;
 583                 }
 584
 585             write_all (mc_global.tty.subshell_pty, pty_buffer, bytes);
 586
 587             if (pty_buffer[bytes - 1] == '\n' || pty_buffer[bytes - 1] == '\r')
 588                 subshell_ready = FALSE;
 589         }
 590         else
 591             return FALSE;
 592     }
 593 }
 594
 595 /* --------------------------------------------------------------------------------------------- */
 596 /* pty opening functions */
 597
 598 #ifdef HAVE_GRANTPT
 599
 600 /* System V version of pty_open_master */
 601
 602 static int
 603 pty_open_master (char *pty_name)
 604 {
 605     char *slave_name;
 606     int pty_master;
 607
 608 #ifdef HAVE_POSIX_OPENPT
 609     pty_master = posix_openpt (O_RDWR);
 610 #elif HAVE_GETPT
 611     /* getpt () is a GNU extension (glibc 2.1.x) */
 612     pty_master = getpt ();
 613 #elif IS_AIX
 614     strcpy (pty_name, "/dev/ptc");
 615     pty_master = open (pty_name, O_RDWR);
 616 #else
 617     strcpy (pty_name, "/dev/ptmx");
 618     pty_master = open (pty_name, O_RDWR);
 619 #endif
 620
 621     if (pty_master == -1)
 622         return -1;
 623
 624     if (grantpt (pty_master) == -1      /* Grant access to slave */
 625         || unlockpt (pty_master) == -1  /* Clear slave's lock flag */
 626         || !(slave_name = ptsname (pty_master)))        /* Get slave's name */
 627     {
 628         close (pty_master);
 629         return -1;
 630     }
 631     strcpy (pty_name, slave_name);
 632     return pty_master;
 633 }
 634
 635 /* --------------------------------------------------------------------------------------------- */
 636 /** System V version of pty_open_slave */
 637
 638 static int
 639 pty_open_slave (const char *pty_name)
 640 {
 641     int pty_slave = open (pty_name, O_RDWR);
 642
 643     if (pty_slave == -1)
 644     {
 645         fprintf (stderr, "open (%s, O_RDWR): %s\r\n", pty_name, unix_error_string (errno));
 646         return -1;
 647     }
 648 #if !defined(__osf__) && !defined(__linux__)
 649 #if defined (I_FIND) && defined (I_PUSH)
 650     if (!ioctl (pty_slave, I_FIND, "ptem"))
 651         if (ioctl (pty_slave, I_PUSH, "ptem") == -1)
 652         {
 653             fprintf (stderr, "ioctl (%d, I_PUSH, \"ptem\") failed: %s\r\n",
 654                      pty_slave, unix_error_string (errno));
 655             close (pty_slave);
 656             return -1;
 657         }
 658
 659     if (!ioctl (pty_slave, I_FIND, "ldterm"))
 660         if (ioctl (pty_slave, I_PUSH, "ldterm") == -1)
 661         {
 662             fprintf (stderr,
 663                      "ioctl (%d, I_PUSH, \"ldterm\") failed: %s\r\n",
 664                      pty_slave, unix_error_string (errno));
 665             close (pty_slave);
 666             return -1;
 667         }
 668 #if !defined(sgi) && !defined(__sgi)
 669     if (!ioctl (pty_slave, I_FIND, "ttcompat"))
 670         if (ioctl (pty_slave, I_PUSH, "ttcompat") == -1)
 671         {
 672             fprintf (stderr,
 673                      "ioctl (%d, I_PUSH, \"ttcompat\") failed: %s\r\n",
 674                      pty_slave, unix_error_string (errno));
 675             close (pty_slave);
 676             return -1;
 677         }
 678 #endif /* sgi || __sgi */
 679 #endif /* I_FIND && I_PUSH */
 680 #endif /* __osf__ || __linux__ */
 681
 682     fcntl (pty_slave, F_SETFD, FD_CLOEXEC);
 683     return pty_slave;
 684 }
 685
 686 #else /* !HAVE_GRANTPT */
 687
 688 /* --------------------------------------------------------------------------------------------- */
 689 /** BSD version of pty_open_master */
 690 static int
 691 pty_open_master (char *pty_name)
 692 {
 693     int pty_master;
 694     const char *ptr1, *ptr2;
 695
 696     strcpy (pty_name, "/dev/ptyXX");
 697     for (ptr1 = "pqrstuvwxyzPQRST"; *ptr1; ++ptr1)
 698     {
 699         pty_name[8] = *ptr1;
 700         for (ptr2 = "0123456789abcdef"; *ptr2 != '\0'; ++ptr2)
 701         {
 702             pty_name[9] = *ptr2;
 703
 704             /* Try to open master */
 705             pty_master = open (pty_name, O_RDWR);
 706             if (pty_master == -1)
 707             {
 708                 if (errno == ENOENT)    /* Different from EIO */
 709                     return -1;  /* Out of pty devices */
 710                 continue;       /* Try next pty device */
 711             }
 712             pty_name[5] = 't';  /* Change "pty" to "tty" */
 713             if (access (pty_name, 6) != 0)
 714             {
 715                 close (pty_master);
 716                 pty_name[5] = 'p';
 717                 continue;
 718             }
 719             return pty_master;
 720         }
 721     }
 722     return -1;                  /* Ran out of pty devices */
 723 }
 724
 725 /* --------------------------------------------------------------------------------------------- */
 726 /** BSD version of pty_open_slave */
 727
 728 static int
 729 pty_open_slave (const char *pty_name)
 730 {
 731     int pty_slave;
 732     struct group *group_info = getgrnam ("tty");
 733
 734     if (group_info != NULL)
 735     {
 736         /* The following two calls will only succeed if we are root */
 737         /* [Commented out while permissions problem is investigated] */
 738         /* chown (pty_name, getuid (), group_info->gr_gid);  FIXME */
 739         /* chmod (pty_name, S_IRUSR | S_IWUSR | S_IWGRP);   FIXME */
 740     }
 741     pty_slave = open (pty_name, O_RDWR);
 742     if (pty_slave == -1)
 743         fprintf (stderr, "open (pty_name, O_RDWR): %s\r\n", pty_name);
 744     fcntl (pty_slave, F_SETFD, FD_CLOEXEC);
 745     return pty_slave;
 746 }
 747 #endif /* !HAVE_GRANTPT */
 748
 749 /* --------------------------------------------------------------------------------------------- */
 750 /*** public functions ****************************************************************************/
 751 /* --------------------------------------------------------------------------------------------- */
 752
 753 /* --------------------------------------------------------------------------------------------- */
 754 /**
 755  *  Fork the subshell, and set up many, many things.
 756  *
 757  *  Possibly modifies the global variables:
 758  *      subshell_type, subshell_alive, subshell_stopped, subshell_pid
 759  *      mc_global.tty.use_subshell - Is set to FALSE if we can't run the subshell
 760  *      quit - Can be set to SUBSHELL_EXIT by the SIGCHLD handler
 761  */
 762
 763 void
 764 init_subshell (void)
 765 {
 766     /* This must be remembered across calls to init_subshell() */
 767     static char pty_name[BUF_SMALL];
 768     char precmd[BUF_SMALL];
 769
 770     switch (check_sid ())
 771     {
 772     case 1:
 773         mc_global.tty.use_subshell = FALSE;
 774         return;
 775     case 2:
 776         mc_global.tty.use_subshell = FALSE;
 777         mc_global.midnight_shutdown = TRUE;
 778         return;
 779     }
 780
 781     /* Take the current (hopefully pristine) tty mode and make */
 782     /* a raw mode based on it now, before we do anything else with it */
 783     init_raw_mode ();
 784
 785     if (mc_global.tty.subshell_pty == 0)
 786     {                           /* First time through */
 787         /* Find out what type of shell we have */
 788
 789         if (strstr (shell, "/zsh") || getenv ("ZSH_VERSION"))
 790             subshell_type = ZSH;
 791         else if (strstr (shell, "/tcsh"))
 792             subshell_type = TCSH;
 793         else if (strstr (shell, "/csh"))
 794             subshell_type = TCSH;
 795         else if (strstr (shell, "/bash") || getenv ("BASH"))
 796             subshell_type = BASH;
 797         else if (strstr (shell, "/fish"))
 798             subshell_type = FISH;
 799         else
 800         {
 801             mc_global.tty.use_subshell = FALSE;
 802             return;
 803         }
 804
 805         /* Open a pty for talking to the subshell */
 806
 807         /* FIXME: We may need to open a fresh pty each time on SVR4 */
 808
 809         mc_global.tty.subshell_pty = pty_open_master (pty_name);
 810         if (mc_global.tty.subshell_pty == -1)
 811         {
 812             fprintf (stderr, "Cannot open master side of pty: %s\r\n", unix_error_string (errno));
 813             mc_global.tty.use_subshell = FALSE;
 814             return;
 815         }
 816         subshell_pty_slave = pty_open_slave (pty_name);
 817         if (subshell_pty_slave == -1)
 818         {
 819             fprintf (stderr, "Cannot open slave side of pty %s: %s\r\n",
 820                      pty_name, unix_error_string (errno));
 821             mc_global.tty.use_subshell = FALSE;
 822             return;
 823         }
 824
 825         /* Create a pipe for receiving the subshell's CWD */
 826
 827         if (subshell_type == TCSH)
 828         {
 829             g_snprintf (tcsh_fifo, sizeof (tcsh_fifo), "%s/mc.pipe.%d",
 830                         mc_tmpdir (), (int) getpid ());
 831             if (mkfifo (tcsh_fifo, 0600) == -1)
 832             {
 833                 fprintf (stderr, "mkfifo(%s) failed: %s\r\n", tcsh_fifo, unix_error_string (errno));
 834                 mc_global.tty.use_subshell = FALSE;
 835                 return;
 836             }
 837
 838             /* Opening the FIFO as O_RDONLY or O_WRONLY causes deadlock */
 839
 840             if ((subshell_pipe[READ] = open (tcsh_fifo, O_RDWR)) == -1
 841                 || (subshell_pipe[WRITE] = open (tcsh_fifo, O_RDWR)) == -1)
 842             {
 843                 fprintf (stderr, _("Cannot open named pipe %s\n"), tcsh_fifo);
 844                 perror (__FILE__ ": open");
 845                 mc_global.tty.use_subshell = FALSE;
 846                 return;
 847             }
 848         }
 849         else /* subshell_type is BASH or ZSH */ if (pipe (subshell_pipe))
 850         {
 851             perror (__FILE__ ": couldn't create pipe");
 852             mc_global.tty.use_subshell = FALSE;
 853             return;
 854         }
 855     }
 856
 857     /* Fork the subshell */
 858
 859     subshell_alive = TRUE;
 860     subshell_stopped = FALSE;
 861     subshell_pid = fork ();
 862
 863     if (subshell_pid == -1)
 864     {
 865         fprintf (stderr, "Cannot spawn the subshell process: %s\r\n", unix_error_string (errno));
 866         /* We exit here because, if the process table is full, the */
 867         /* other method of running user commands won't work either */
 868         exit (EXIT_FAILURE);
 869     }
 870
 871     if (subshell_pid == 0)
 872     {
 873         /* We are in the child process */
 874         init_subshell_child (pty_name);
 875     }
 876
 877     /* Set up `precmd' or equivalent for reading the subshell's CWD */
 878
 879     switch (subshell_type)
 880     {
 881     case BASH:
 882         g_snprintf (precmd, sizeof (precmd),
 883                     " PROMPT_COMMAND='pwd>&%d;kill -STOP $$'\n", subshell_pipe[WRITE]);
 884         break;
 885
 886     case ZSH:
 887         g_snprintf (precmd, sizeof (precmd),
 888                     " precmd(){ pwd>&%d;kill -STOP $$ }\n", subshell_pipe[WRITE]);
 889         break;
 890
 891     case TCSH:
 892         g_snprintf (precmd, sizeof (precmd),
 893                     "set echo_style=both;"
 894                     "alias precmd 'echo $cwd:q >>%s;kill -STOP $$'\n", tcsh_fifo);
 895         break;
 896     case FISH:
 897         g_snprintf (precmd, sizeof (precmd),
 898                     "function fish_prompt ; pwd>&%d;kill -STOP %%self; end\n",
 899                     subshell_pipe[WRITE]);
 900         break;
 901
 902     }
 903     write_all (mc_global.tty.subshell_pty, precmd, strlen (precmd));
 904
 905     /* Wait until the subshell has started up and processed the command */
 906
 907     subshell_state = RUNNING_COMMAND;
 908     tty_enable_interrupt_key ();
 909     if (!feed_subshell (QUIETLY, TRUE))
 910     {
 911         mc_global.tty.use_subshell = FALSE;
 912     }
 913     tty_disable_interrupt_key ();
 914     if (!subshell_alive)
 915         mc_global.tty.use_subshell = FALSE;     /* Subshell died instantly, so don't use it */
 916 }
 917
 918 /* --------------------------------------------------------------------------------------------- */
 919
 920 int
 921 invoke_subshell (const char *command, int how, vfs_path_t ** new_dir_vpath)
 922 {
 923     char *pcwd;
 924
 925     /* Make the MC terminal transparent */
 926     tcsetattr (STDOUT_FILENO, TCSANOW, &raw_mode);
 927
 928     /* Make the subshell change to MC's working directory */
 929     if (new_dir_vpath != NULL)
 930         do_subshell_chdir (current_panel->cwd_vpath, TRUE, TRUE);
 931
 932     if (command == NULL)        /* The user has done "C-o" from MC */
 933     {
 934         if (subshell_state == INACTIVE)
 935         {
 936             subshell_state = ACTIVE;
 937             /* FIXME: possibly take out this hack; the user can
 938                re-play it by hitting C-hyphen a few times! */
 939             if (subshell_ready)
 940                 write_all (mc_global.tty.subshell_pty, " \b", 2);       /* Hack to make prompt reappear */
 941         }
 942     }
 943     else                        /* MC has passed us a user command */
 944     {
 945         if (how == QUIETLY)
 946             write_all (mc_global.tty.subshell_pty, " ", 1);
 947         /* FIXME: if command is long (>8KB ?) we go comma */
 948         write_all (mc_global.tty.subshell_pty, command, strlen (command));
 949         write_all (mc_global.tty.subshell_pty, "\n", 1);
 950         subshell_state = RUNNING_COMMAND;
 951         subshell_ready = FALSE;
 952     }
 953
 954     feed_subshell (how, FALSE);
 955
 956     {
 957         char *cwd_str;
 958
 959         cwd_str = vfs_path_to_str (current_panel->cwd_vpath);
 960         pcwd = vfs_translate_path_n (cwd_str);
 961         g_free (cwd_str);
 962     }
 963
 964     if (new_dir_vpath != NULL && subshell_alive && strcmp (subshell_cwd, pcwd))
 965         *new_dir_vpath = vfs_path_from_str (subshell_cwd);      /* Make MC change to the subshell's CWD */
 966     g_free (pcwd);
 967
 968     /* Restart the subshell if it has died by SIGHUP, SIGQUIT, etc. */
 969     while (!subshell_alive && quit == 0 && mc_global.tty.use_subshell)
 970         init_subshell ();
 971
 972     prompt_pos = 0;
 973
 974     return quit;
 975 }
 976
 977
 978 /* --------------------------------------------------------------------------------------------- */
 979
 980 int
 981 read_subshell_prompt (void)
 982 {
 983     static int prompt_size = INITIAL_PROMPT_SIZE;
 984     int bytes = 0, i, rc = 0;
 985     struct timeval timeleft = { 0, 0 };
 986
 987     fd_set tmp;
 988     FD_ZERO (&tmp);
 989     FD_SET (mc_global.tty.subshell_pty, &tmp);
 990
 991     if (subshell_prompt == NULL)
 992     {                           /* First time through */
 993         subshell_prompt = g_malloc (prompt_size);
 994         *subshell_prompt = '\0';
 995         prompt_pos = 0;
 996     }
 997
 998     while (subshell_alive
 999            && (rc = select (mc_global.tty.subshell_pty + 1, &tmp, NULL, NULL, &timeleft)))
1000     {
1001         /* Check for `select' errors */
1002         if (rc == -1)
1003         {
1004             if (errno == EINTR)
1005                 continue;
1006             else
1007             {
1008                 fprintf (stderr, "select (FD_SETSIZE, &tmp...): %s\r\n", unix_error_string (errno));
1009                 exit (EXIT_FAILURE);
1010             }
1011         }
1012
1013         bytes = read (mc_global.tty.subshell_pty, pty_buffer, sizeof (pty_buffer));
1014
1015         /* Extract the prompt from the shell output */
1016
1017         for (i = 0; i < bytes; ++i)
1018             if (pty_buffer[i] == '\n' || pty_buffer[i] == '\r')
1019             {
1020                 prompt_pos = 0;
1021             }
1022             else
1023             {
1024                 if (!pty_buffer[i])
1025                     continue;
1026
1027                 subshell_prompt[prompt_pos++] = pty_buffer[i];
1028                 if (prompt_pos == prompt_size)
1029                     subshell_prompt = g_realloc (subshell_prompt, prompt_size *= 2);
1030             }
1031
1032         subshell_prompt[prompt_pos] = '\0';
1033     }
1034     if (rc == 0 && bytes == 0)
1035         return FALSE;
1036     return TRUE;
1037 }
1038
1039 /* --------------------------------------------------------------------------------------------- */
1040
1041 void
1042 do_update_prompt (void)
1043 {
1044     if (update_subshell_prompt)
1045     {
1046         printf ("\r\n%s", subshell_prompt);
1047         fflush (stdout);
1048         update_subshell_prompt = FALSE;
1049     }
1050 }
1051
1052 /* --------------------------------------------------------------------------------------------- */
1053
1054 int
1055 exit_subshell (void)
1056 {
1057     int subshell_quit = TRUE;
1058
1059     if (subshell_state != INACTIVE && subshell_alive)
1060         subshell_quit =
1061             !query_dialog (_("Warning"),
1062                            _("The shell is still active. Quit anyway?"),
1063                            D_NORMAL, 2, _("&Yes"), _("&No"));
1064
1065     if (subshell_quit)
1066     {
1067         if (subshell_type == TCSH)
1068         {
1069             if (unlink (tcsh_fifo) == -1)
1070                 fprintf (stderr, "Cannot remove named pipe %s: %s\r\n",
1071                          tcsh_fifo, unix_error_string (errno));
1072         }
1073
1074         g_free (subshell_prompt);
1075         subshell_prompt = NULL;
1076         pty_buffer[0] = '\0';
1077     }
1078
1079     return subshell_quit;
1080 }
1081
1082 /* --------------------------------------------------------------------------------------------- */
1083 /**
1084  * Carefully quote directory name to allow entering any directory safely,
1085  * no matter what weird characters it may contain in its name.
1086  * NOTE: Treat directory name an untrusted data, don't allow it to cause
1087  * executing any commands in the shell.  Escape all control characters.
1088  * Use following technique:
1089  *
1090  * printf(1) with format string containing a single conversion specifier,
1091  * "b", and an argument which contains a copy of the string passed to
1092  * subshell_name_quote() with all characters, except digits and letters,
1093  * replaced by the backslash-escape sequence \0nnn, where "nnn" is the
1094  * numeric value of the character converted to octal number.
1095  *
1096  *   cd "`printf "%b" 'ABC\0nnnDEF\0nnnXYZ'`"
1097  *
1098  */
1099
1100 static char *
1101 subshell_name_quote (const char *s)
1102 {
1103     char *ret, *d;
1104     const char *su, *n;
1105     const char *quote_cmd_start, *quote_cmd_end;
1106     int c;
1107
1108     if (subshell_type == FISH)
1109     {
1110         quote_cmd_start = "(printf \"%b\" '";
1111         quote_cmd_end = "')";
1112     }
1113     else
1114     {
1115         quote_cmd_start = "\"`printf \"%b\" '";
1116         quote_cmd_end = "'`\"";
1117     }
1118
1119     /* Factor 5 because we need \, 0 and 3 other digits per character. */
1120     d = ret = g_try_malloc (1 + (5 * strlen (s)) + (strlen (quote_cmd_start))
1121                             + (strlen (quote_cmd_end)));
1122     if (d == NULL)
1123         return NULL;
1124
1125     /* Prevent interpreting leading `-' as a switch for `cd' */
1126     if (*s == '-')
1127     {
1128         *d++ = '.';
1129         *d++ = '/';
1130     }
1131
1132     /* Copy the beginning of the command to the buffer */
1133     strcpy (d, quote_cmd_start);
1134     d += strlen (quote_cmd_start);
1135
1136     /*
1137      * Print every character except digits and letters as a backslash-escape
1138      * sequence of the form \0nnn, where "nnn" is the numeric value of the
1139      * character converted to octal number.
1140      */
1141     su = s;
1142     for (; su[0] != '\0';)
1143     {
1144         n = str_cget_next_char_safe (su);
1145         if (str_isalnum (su))
1146         {
1147             memcpy (d, su, n - su);
1148             d += n - su;
1149         }
1150         else
1151         {
1152             for (c = 0; c < n - su; c++)
1153             {
1154                 sprintf (d, "\\0%03o", (unsigned char) su[c]);
1155                 d += 5;
1156             }
1157         }
1158         su = n;
1159     }
1160
1161     strcpy (d, quote_cmd_end);
1162
1163     return ret;
1164 }
1165
1166
1167 /* --------------------------------------------------------------------------------------------- */
1168
1169 /** If it actually changed the directory it returns true */
1170 void
1171 do_subshell_chdir (const vfs_path_t * vpath, gboolean update_prompt, gboolean reset_prompt)
1172 {
1173     char *pcwd;
1174     char *temp;
1175     char *directory;
1176
1177     pcwd = vfs_path_to_str_flags (current_panel->cwd_vpath, 0, VPF_RECODE);
1178
1179     if (!(subshell_state == INACTIVE && strcmp (subshell_cwd, pcwd) != 0))
1180     {
1181         /* We have to repaint the subshell prompt if we read it from
1182          * the main program.  Please note that in the code after this
1183          * if, the cd command that is sent will make the subshell
1184          * repaint the prompt, so we don't have to paint it. */
1185         if (update_prompt)
1186             do_update_prompt ();
1187         g_free (pcwd);
1188         return;
1189     }
1190
1191     /* The initial space keeps this out of the command history (in bash
1192        because we set "HISTCONTROL=ignorespace") */
1193     write_all (mc_global.tty.subshell_pty, " cd ", 4);
1194
1195     directory = vfs_path_to_str (vpath);
1196     if (directory != '\0')
1197     {
1198         char *translate;
1199
1200         translate = vfs_translate_path_n (directory);
1201         if (translate != NULL)
1202         {
1203             temp = subshell_name_quote (translate);
1204             if (temp)
1205             {
1206                 write_all (mc_global.tty.subshell_pty, temp, strlen (temp));
1207                 g_free (temp);
1208             }
1209             else
1210             {
1211                 /* Should not happen unless the directory name is so long
1212                    that we don't have memory to quote it.  */
1213                 write_all (mc_global.tty.subshell_pty, ".", 1);
1214             }
1215             g_free (translate);
1216         }
1217         else
1218         {
1219             write_all (mc_global.tty.subshell_pty, ".", 1);
1220         }
1221     }
1222     else
1223     {
1224         write_all (mc_global.tty.subshell_pty, "/", 1);
1225     }
1226     g_free (directory);
1227     write_all (mc_global.tty.subshell_pty, "\n", 1);
1228
1229     subshell_state = RUNNING_COMMAND;
1230     feed_subshell (QUIETLY, FALSE);
1231
1232     if (subshell_alive)
1233     {
1234         int bPathNotEq = strcmp (subshell_cwd, pcwd);
1235
1236         if (bPathNotEq && subshell_type == TCSH)
1237         {
1238             char rp_subshell_cwd[PATH_MAX];
1239             char rp_current_panel_cwd[PATH_MAX];
1240
1241             char *p_subshell_cwd = mc_realpath (subshell_cwd, rp_subshell_cwd);
1242             char *p_current_panel_cwd = mc_realpath (pcwd, rp_current_panel_cwd);
1243
1244             if (p_subshell_cwd == NULL)
1245                 p_subshell_cwd = subshell_cwd;
1246             if (p_current_panel_cwd == NULL)
1247                 p_current_panel_cwd = pcwd;
1248             bPathNotEq = strcmp (p_subshell_cwd, p_current_panel_cwd);
1249         }
1250
1251         if (bPathNotEq && strcmp (pcwd, ".") != 0)
1252         {
1253             char *cwd;
1254
1255             cwd = vfs_path_to_str_flags (current_panel->cwd_vpath, 0, VPF_STRIP_PASSWORD);
1256             vfs_print_message (_("Warning: Cannot change to %s.\n"), cwd);
1257             g_free (cwd);
1258         }
1259     }
1260
1261     if (reset_prompt)
1262         prompt_pos = 0;
1263     update_subshell_prompt = FALSE;
1264
1265     g_free (pcwd);
1266     /* Make sure that MC never stores the CWD in a silly format */
1267     /* like /usr////lib/../bin, or the strcmp() above will fail */
1268 }
1269
1270 /* --------------------------------------------------------------------------------------------- */
1271
1272 void
1273 subshell_get_console_attributes (void)
1274 {
1275     /* Get our current terminal modes */
1276
1277     if (tcgetattr (STDOUT_FILENO, &shell_mode))
1278     {
1279         fprintf (stderr, "Cannot get terminal settings: %s\r\n", unix_error_string (errno));
1280         mc_global.tty.use_subshell = FALSE;
1281     }
1282 }
1283
1284 /* --------------------------------------------------------------------------------------------- */
1285 /**
1286  * Figure out whether the subshell has stopped, exited or been killed
1287  * Possibly modifies: `subshell_alive', `subshell_stopped' and `quit' */
1288
1289 void
1290 sigchld_handler (int sig)
1291 {
1292     int status;
1293     pid_t pid;
1294
1295     (void) sig;
1296
1297     pid = waitpid (subshell_pid, &status, WUNTRACED | WNOHANG);
1298
1299     if (pid == subshell_pid)
1300     {
1301         /* Figure out what has happened to the subshell */
1302
1303         if (WIFSTOPPED (status))
1304         {
1305             if (WSTOPSIG (status) == SIGSTOP)
1306             {
1307                 /* The subshell has received a SIGSTOP signal */
1308                 subshell_stopped = TRUE;
1309             }
1310             else
1311             {
1312                 /* The user has suspended the subshell.  Revive it */
1313                 kill (subshell_pid, SIGCONT);
1314             }
1315         }
1316         else
1317         {
1318             /* The subshell has either exited normally or been killed */
1319             subshell_alive = FALSE;
1320             delete_select_channel (mc_global.tty.subshell_pty);
1321             if (WIFEXITED (status) && WEXITSTATUS (status) != FORK_FAILURE)
1322                 quit |= SUBSHELL_EXIT;  /* Exited normally */
1323         }
1324     }
1325 #ifdef __linux__
1326     pid = waitpid (cons_saver_pid, &status, WUNTRACED | WNOHANG);
1327
1328     if (pid == cons_saver_pid)
1329     {
1330
1331         if (WIFSTOPPED (status))
1332             /* Someone has stopped cons.saver - restart it */
1333             kill (pid, SIGCONT);
1334         else
1335         {
1336             /* cons.saver has died - disable confole saving */
1337             handle_console (CONSOLE_DONE);
1338             mc_global.tty.console_flag = '\0';
1339         }
1340
1341     }
1342 #endif /* __linux__ */
1343
1344     /* If we got here, some other child exited; ignore it */
1345 }
1346
1347 /* --------------------------------------------------------------------------------------------- */
1348
1349 #endif /* HAVE_SUBSHELL_SUPPORT */