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