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