src/subshell.c

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