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 = g_build_filename (mc_config_get_path (), "bashrc", NULL);
 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 = g_build_filename (mc_config_get_path (), "inputrc", NULL);
 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.widget.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, char **new_dir)
 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 != NULL)
 930         do_subshell_chdir (current_panel->cwd, 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     pcwd = vfs_translate_path_n (current_panel->cwd);
 957     if (new_dir && subshell_alive && strcmp (subshell_cwd, pcwd))
 958         *new_dir = subshell_cwd;        /* Make MC change to the subshell's CWD */
 959     g_free (pcwd);
 960
 961     /* Restart the subshell if it has died by SIGHUP, SIGQUIT, etc. */
 962     while (!subshell_alive && quit == 0 && mc_global.tty.use_subshell)
 963         init_subshell ();
 964
 965     prompt_pos = 0;
 966
 967     return quit;
 968 }
 969
 970
 971 /* --------------------------------------------------------------------------------------------- */
 972
 973 int
 974 read_subshell_prompt (void)
 975 {
 976     static int prompt_size = INITIAL_PROMPT_SIZE;
 977     int bytes = 0, i, rc = 0;
 978     struct timeval timeleft = { 0, 0 };
 979
 980     fd_set tmp;
 981     FD_ZERO (&tmp);
 982     FD_SET (mc_global.tty.subshell_pty, &tmp);
 983
 984     if (subshell_prompt == NULL)
 985     {                           /* First time through */
 986         subshell_prompt = g_malloc (prompt_size);
 987         *subshell_prompt = '\0';
 988         prompt_pos = 0;
 989     }
 990
 991     while (subshell_alive
 992            && (rc = select (mc_global.tty.subshell_pty + 1, &tmp, NULL, NULL, &timeleft)))
 993     {
 994         /* Check for `select' errors */
 995         if (rc == -1)
 996         {
 997             if (errno == EINTR)
 998                 continue;
 999             else
1000             {
1001                 fprintf (stderr, "select (FD_SETSIZE, &tmp...): %s\r\n", unix_error_string (errno));
1002                 exit (EXIT_FAILURE);
1003             }
1004         }
1005
1006         bytes = read (mc_global.tty.subshell_pty, pty_buffer, sizeof (pty_buffer));
1007
1008         /* Extract the prompt from the shell output */
1009
1010         for (i = 0; i < bytes; ++i)
1011             if (pty_buffer[i] == '\n' || pty_buffer[i] == '\r')
1012             {
1013                 prompt_pos = 0;
1014             }
1015             else
1016             {
1017                 if (!pty_buffer[i])
1018                     continue;
1019
1020                 subshell_prompt[prompt_pos++] = pty_buffer[i];
1021                 if (prompt_pos == prompt_size)
1022                     subshell_prompt = g_realloc (subshell_prompt, prompt_size *= 2);
1023             }
1024
1025         subshell_prompt[prompt_pos] = '\0';
1026     }
1027     if (rc == 0 && bytes == 0)
1028         return FALSE;
1029     return TRUE;
1030 }
1031
1032 /* --------------------------------------------------------------------------------------------- */
1033
1034 void
1035 do_update_prompt (void)
1036 {
1037     if (update_subshell_prompt)
1038     {
1039         printf ("\r\n%s", subshell_prompt);
1040         fflush (stdout);
1041         update_subshell_prompt = FALSE;
1042     }
1043 }
1044
1045 /* --------------------------------------------------------------------------------------------- */
1046
1047 int
1048 exit_subshell (void)
1049 {
1050     int subshell_quit = TRUE;
1051
1052     if (subshell_state != INACTIVE && subshell_alive)
1053         subshell_quit =
1054             !query_dialog (_("Warning"),
1055                            _("The shell is still active. Quit anyway?"),
1056                            D_NORMAL, 2, _("&Yes"), _("&No"));
1057
1058     if (subshell_quit)
1059     {
1060         if (subshell_type == TCSH)
1061         {
1062             if (unlink (tcsh_fifo) == -1)
1063                 fprintf (stderr, "Cannot remove named pipe %s: %s\r\n",
1064                          tcsh_fifo, unix_error_string (errno));
1065         }
1066
1067         g_free (subshell_prompt);
1068         subshell_prompt = NULL;
1069         pty_buffer[0] = '\0';
1070     }
1071
1072     return subshell_quit;
1073 }
1074
1075 /* --------------------------------------------------------------------------------------------- */
1076 /**
1077  * Carefully quote directory name to allow entering any directory safely,
1078  * no matter what weird characters it may contain in its name.
1079  * NOTE: Treat directory name an untrusted data, don't allow it to cause
1080  * executing any commands in the shell.  Escape all control characters.
1081  * Use following technique:
1082  *
1083  * printf(1) with format string containing a single conversion specifier,
1084  * "b", and an argument which contains a copy of the string passed to
1085  * subshell_name_quote() with all characters, except digits and letters,
1086  * replaced by the backslash-escape sequence \0nnn, where "nnn" is the
1087  * numeric value of the character converted to octal number.
1088  *
1089  *   cd "`printf "%b" 'ABC\0nnnDEF\0nnnXYZ'`"
1090  *
1091  */
1092
1093 static char *
1094 subshell_name_quote (const char *s)
1095 {
1096     char *ret, *d;
1097     const char *su, *n;
1098     const char *quote_cmd_start, *quote_cmd_end;
1099     int c;
1100
1101     if (subshell_type == FISH)
1102     {
1103         quote_cmd_start = "(printf \"%b\" '";
1104         quote_cmd_end = "')";
1105     }
1106     else
1107     {
1108         quote_cmd_start = "\"`printf \"%b\" '";
1109         quote_cmd_end = "'`\"";
1110     }
1111
1112     /* Factor 5 because we need \, 0 and 3 other digits per character. */
1113     d = ret = g_try_malloc (1 + (5 * strlen (s)) + (strlen (quote_cmd_start))
1114                             + (strlen (quote_cmd_end)));
1115     if (d == NULL)
1116         return NULL;
1117
1118     /* Prevent interpreting leading `-' as a switch for `cd' */
1119     if (*s == '-')
1120     {
1121         *d++ = '.';
1122         *d++ = '/';
1123     }
1124
1125     /* Copy the beginning of the command to the buffer */
1126     strcpy (d, quote_cmd_start);
1127     d += strlen (quote_cmd_start);
1128
1129     /*
1130      * Print every character except digits and letters as a backslash-escape
1131      * sequence of the form \0nnn, where "nnn" is the numeric value of the
1132      * character converted to octal number.
1133      */
1134     su = s;
1135     for (; su[0] != '\0';)
1136     {
1137         n = str_cget_next_char_safe (su);
1138         if (str_isalnum (su))
1139         {
1140             memcpy (d, su, n - su);
1141             d += n - su;
1142         }
1143         else
1144         {
1145             for (c = 0; c < n - su; c++)
1146             {
1147                 sprintf (d, "\\0%03o", (unsigned char) su[c]);
1148                 d += 5;
1149             }
1150         }
1151         su = n;
1152     }
1153
1154     strcpy (d, quote_cmd_end);
1155
1156     return ret;
1157 }
1158
1159
1160 /* --------------------------------------------------------------------------------------------- */
1161
1162 /** If it actually changed the directory it returns true */
1163 void
1164 do_subshell_chdir (const char *directory, gboolean update_prompt, gboolean reset_prompt)
1165 {
1166     char *pcwd;
1167     char *temp;
1168     char *translate;
1169
1170     pcwd = vfs_translate_path_n (current_panel->cwd);
1171
1172     if (!(subshell_state == INACTIVE && strcmp (subshell_cwd, pcwd) != 0))
1173     {
1174         /* We have to repaint the subshell prompt if we read it from
1175          * the main program.  Please note that in the code after this
1176          * if, the cd command that is sent will make the subshell
1177          * repaint the prompt, so we don't have to paint it. */
1178         if (update_prompt)
1179             do_update_prompt ();
1180         g_free (pcwd);
1181         return;
1182     }
1183
1184     /* The initial space keeps this out of the command history (in bash
1185        because we set "HISTCONTROL=ignorespace") */
1186     write_all (mc_global.tty.subshell_pty, " cd ", 4);
1187     if (*directory)
1188     {
1189         translate = vfs_translate_path_n (directory);
1190         if (translate)
1191         {
1192             temp = subshell_name_quote (translate);
1193             if (temp)
1194             {
1195                 write_all (mc_global.tty.subshell_pty, temp, strlen (temp));
1196                 g_free (temp);
1197             }
1198             else
1199             {
1200                 /* Should not happen unless the directory name is so long
1201                    that we don't have memory to quote it.  */
1202                 write_all (mc_global.tty.subshell_pty, ".", 1);
1203             }
1204             g_free (translate);
1205         }
1206         else
1207         {
1208             write_all (mc_global.tty.subshell_pty, ".", 1);
1209         }
1210     }
1211     else
1212     {
1213         write_all (mc_global.tty.subshell_pty, "/", 1);
1214     }
1215     write_all (mc_global.tty.subshell_pty, "\n", 1);
1216
1217     subshell_state = RUNNING_COMMAND;
1218     feed_subshell (QUIETLY, FALSE);
1219
1220     if (subshell_alive)
1221     {
1222         int bPathNotEq = strcmp (subshell_cwd, pcwd);
1223
1224         if (bPathNotEq && subshell_type == TCSH)
1225         {
1226             char rp_subshell_cwd[PATH_MAX];
1227             char rp_current_panel_cwd[PATH_MAX];
1228
1229             char *p_subshell_cwd = mc_realpath (subshell_cwd, rp_subshell_cwd);
1230             char *p_current_panel_cwd = mc_realpath (pcwd, rp_current_panel_cwd);
1231
1232             if (p_subshell_cwd == NULL)
1233                 p_subshell_cwd = subshell_cwd;
1234             if (p_current_panel_cwd == NULL)
1235                 p_current_panel_cwd = pcwd;
1236             bPathNotEq = strcmp (p_subshell_cwd, p_current_panel_cwd);
1237         }
1238
1239         if (bPathNotEq && strcmp (pcwd, "."))
1240         {
1241             char *cwd = strip_password (g_strdup (pcwd), 1);
1242             fprintf (stderr, _("Warning: Cannot change to %s.\n"), cwd);
1243             g_free (cwd);
1244         }
1245     }
1246
1247     if (reset_prompt)
1248         prompt_pos = 0;
1249     update_subshell_prompt = FALSE;
1250
1251     g_free (pcwd);
1252     /* Make sure that MC never stores the CWD in a silly format */
1253     /* like /usr////lib/../bin, or the strcmp() above will fail */
1254 }
1255
1256 /* --------------------------------------------------------------------------------------------- */
1257
1258 void
1259 subshell_get_console_attributes (void)
1260 {
1261     /* Get our current terminal modes */
1262
1263     if (tcgetattr (STDOUT_FILENO, &shell_mode))
1264     {
1265         fprintf (stderr, "Cannot get terminal settings: %s\r\n", unix_error_string (errno));
1266         mc_global.tty.use_subshell = FALSE;
1267         return;
1268     }
1269 }
1270
1271 /* --------------------------------------------------------------------------------------------- */
1272 /**
1273  * Figure out whether the subshell has stopped, exited or been killed
1274  * Possibly modifies: `subshell_alive', `subshell_stopped' and `quit' */
1275
1276 void
1277 sigchld_handler (int sig)
1278 {
1279     int status;
1280     pid_t pid;
1281
1282     (void) sig;
1283
1284     pid = waitpid (subshell_pid, &status, WUNTRACED | WNOHANG);
1285
1286     if (pid == subshell_pid)
1287     {
1288         /* Figure out what has happened to the subshell */
1289
1290         if (WIFSTOPPED (status))
1291         {
1292             if (WSTOPSIG (status) == SIGSTOP)
1293             {
1294                 /* The subshell has received a SIGSTOP signal */
1295                 subshell_stopped = TRUE;
1296             }
1297             else
1298             {
1299                 /* The user has suspended the subshell.  Revive it */
1300                 kill (subshell_pid, SIGCONT);
1301             }
1302         }
1303         else
1304         {
1305             /* The subshell has either exited normally or been killed */
1306             subshell_alive = FALSE;
1307             delete_select_channel (mc_global.tty.subshell_pty);
1308             if (WIFEXITED (status) && WEXITSTATUS (status) != FORK_FAILURE)
1309                 quit |= SUBSHELL_EXIT;  /* Exited normally */
1310         }
1311     }
1312 #ifdef __linux__
1313     pid = waitpid (cons_saver_pid, &status, WUNTRACED | WNOHANG);
1314
1315     if (pid == cons_saver_pid)
1316     {
1317
1318         if (WIFSTOPPED (status))
1319             /* Someone has stopped cons.saver - restart it */
1320             kill (pid, SIGCONT);
1321         else
1322         {
1323             /* cons.saver has died - disable confole saving */
1324             handle_console (CONSOLE_DONE);
1325             mc_global.tty.console_flag = '\0';
1326         }
1327
1328     }
1329 #endif /* __linux__ */
1330
1331     /* If we got here, some other child exited; ignore it */
1332 }
1333
1334 /* --------------------------------------------------------------------------------------------- */
1335
1336 #endif /* HAVE_SUBSHELL_SUPPORT */