Added new fnction for manipulate vpath objects:
[midnight-commander.git] / src / subshell.c
blob4a77e929511e5d57e47185443a969390ce6de825
1 /*
2 Concurrent shell support for the Midnight Commander
4 Copyright (C) 1994, 1995, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
5 2005, 2006, 2007, 2011
6 The Free Software Foundation, Inc.
8 This file is part of the Midnight Commander.
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.
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.
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/>.
24 /** \file subshell.c
25 * \brief Source: concurrent shell support
28 #include <config.h>
30 #ifdef HAVE_SUBSHELL_SUPPORT
32 #ifndef _GNU_SOURCE
33 #define _GNU_SOURCE 1
34 #endif
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>
51 #ifdef HAVE_STROPTS_H
52 #include <stropts.h> /* For I_PUSH */
53 #endif /* HAVE_STROPTS_H */
55 #include "lib/global.h"
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"
65 #include "filemanager/midnight.h" /* current_panel */
67 #include "consaver/cons.saver.h" /* handle_console() */
68 #include "subshell.h"
70 /*** global variables ****************************************************************************/
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;
78 /* Holds the latest prompt captured from the subshell */
79 char *subshell_prompt = NULL;
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;
85 /*** file scope macro definitions ****************************************************************/
87 #ifndef WEXITSTATUS
88 #define WEXITSTATUS(stat_val) ((unsigned)(stat_val) >> 8)
89 #endif
91 #ifndef WIFEXITED
92 #define WIFEXITED(stat_val) (((stat_val) & 255) == 0)
93 #endif
95 #ifndef STDIN_FILENO
96 #define STDIN_FILENO 0
97 #endif
99 #ifndef STDOUT_FILENO
100 #define STDOUT_FILENO 1
101 #endif
103 #ifndef STDERR_FILENO
104 #define STDERR_FILENO 2
105 #endif
107 /* Initial length of the buffer for the subshell's prompt */
108 #define INITIAL_PROMPT_SIZE 10
110 /* Used by the child process to indicate failure to start the subshell */
111 #define FORK_FAILURE 69 /* Arbitrary */
113 /* Length of the buffer for all I/O with the subshell */
114 #define PTY_BUFFER_SIZE BUF_SMALL /* Arbitrary; but keep it >= 80 */
116 /*** file scope type declarations ****************************************************************/
118 /* For pipes */
119 enum
121 READ = 0,
122 WRITE = 1
125 /* Subshell type (gleaned from the SHELL environment variable, if available) */
126 static enum
128 BASH,
129 TCSH,
130 ZSH,
131 FISH
132 } subshell_type;
134 /*** file scope variables ************************************************************************/
136 /* tcsh closes all non-standard file descriptors, so we have to use a pipe */
137 static char tcsh_fifo[128];
139 static int subshell_pty_slave = -1;
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* */
146 /* For reading/writing on the subshell's pty */
147 static char pty_buffer[PTY_BUFFER_SIZE] = "\0";
149 /* To pass CWD info from the subshell to MC */
150 static int subshell_pipe[2];
152 /* The subshell's process ID */
153 static pid_t subshell_pid = 1;
155 /* One extra char for final '\n' */
156 static char subshell_cwd[MC_MAXPATHLEN + 1];
158 /* Flag to indicate whether the subshell is ready for next command */
159 static int subshell_ready;
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;
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;
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;
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;
180 /*** file scope functions ************************************************************************/
181 /* --------------------------------------------------------------------------------------------- */
183 * Write all data, even if the write() call is interrupted.
186 static ssize_t
187 write_all (int fd, const void *buf, size_t count)
189 ssize_t ret;
190 ssize_t written = 0;
191 while (count > 0)
193 ret = write (fd, (const unsigned char *) buf + written, count);
194 if (ret < 0)
196 if (errno == EINTR)
198 continue;
200 else
202 return written > 0 ? written : ret;
205 count -= ret;
206 written += ret;
208 return written;
211 /* --------------------------------------------------------------------------------------------- */
213 * Prepare child process to running the shell and run it.
215 * Modifies the global variables (in the child process only):
216 * shell_mode
218 * Returns: never.
221 static void
222 init_subshell_child (const char *pty_name)
224 char *init_file = NULL;
225 pid_t mc_sid;
227 (void) pty_name;
228 setsid (); /* Get a fresh terminal session */
230 /* Make sure that it has become our controlling terminal */
232 /* Redundant on Linux and probably most systems, but just in case: */
234 #ifdef TIOCSCTTY
235 ioctl (subshell_pty_slave, TIOCSCTTY, 0);
236 #endif
238 /* Configure its terminal modes and window size */
240 /* Set up the pty with the same termios flags as our own tty */
241 if (tcsetattr (subshell_pty_slave, TCSANOW, &shell_mode))
243 fprintf (stderr, "Cannot set pty terminal modes: %s\r\n", unix_error_string (errno));
244 _exit (FORK_FAILURE);
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);
251 /* Set up the subshell's environment and init file name */
253 /* It simplifies things to change to our home directory here, */
254 /* and the user's startup file may do a `cd' command anyway */
256 int ret;
257 ret = chdir (mc_config_get_home_dir ()); /* FIXME? What about when we re-run the subshell? */
260 /* Set MC_SID to prevent running one mc from another */
261 mc_sid = getsid (0);
262 if (mc_sid != -1)
264 char sid_str[BUF_SMALL];
265 g_snprintf (sid_str, sizeof (sid_str), "MC_SID=%ld", (long) mc_sid);
266 putenv (g_strdup (sid_str));
269 switch (subshell_type)
271 case BASH:
272 init_file = mc_config_get_full_path ("bashrc");
274 if (access (init_file, R_OK) == -1)
276 g_free (init_file);
277 init_file = g_strdup (".bashrc");
280 /* Make MC's special commands not show up in bash's history */
281 putenv ((char *) "HISTCONTROL=ignorespace");
283 /* Allow alternative readline settings for MC */
285 char *input_file = mc_config_get_full_path ("inputrc");
286 if (access (input_file, R_OK) == 0)
288 char *putenv_str = g_strconcat ("INPUTRC=", input_file, NULL);
289 putenv (putenv_str);
290 g_free (putenv_str);
292 g_free (input_file);
295 break;
297 /* TODO: Find a way to pass initfile to TCSH and ZSH */
298 case TCSH:
299 case ZSH:
300 case FISH:
301 break;
303 default:
304 fprintf (stderr, __FILE__ ": unimplemented subshell type %d\r\n", subshell_type);
305 _exit (FORK_FAILURE);
308 /* Attach all our standard file descriptors to the pty */
310 /* This is done just before the fork, because stderr must still */
311 /* be connected to the real tty during the above error messages; */
312 /* otherwise the user will never see them. */
314 dup2 (subshell_pty_slave, STDIN_FILENO);
315 dup2 (subshell_pty_slave, STDOUT_FILENO);
316 dup2 (subshell_pty_slave, STDERR_FILENO);
318 close (subshell_pipe[READ]);
319 close (subshell_pty_slave); /* These may be FD_CLOEXEC, but just in case... */
320 /* Close master side of pty. This is important; apart from */
321 /* freeing up the descriptor for use in the subshell, it also */
322 /* means that when MC exits, the subshell will get a SIGHUP and */
323 /* exit too, because there will be no more descriptors pointing */
324 /* at the master side of the pty and so it will disappear. */
325 close (mc_global.tty.subshell_pty);
327 /* Execute the subshell at last */
329 switch (subshell_type)
331 case BASH:
332 execl (shell, "bash", "-rcfile", init_file, (char *) NULL);
333 break;
335 case TCSH:
336 execl (shell, "tcsh", (char *) NULL);
337 break;
339 case ZSH:
340 /* Use -g to exclude cmds beginning with space from history
341 * and -Z to use the line editor on non-interactive term */
342 execl (shell, "zsh", "-Z", "-g", (char *) NULL);
344 break;
346 case FISH:
347 execl (shell, "fish", (char *) NULL);
348 break;
351 /* If we get this far, everything failed miserably */
352 g_free (init_file);
353 _exit (FORK_FAILURE);
357 /* --------------------------------------------------------------------------------------------- */
359 * Check MC_SID to prevent running one mc from another.
360 * Return:
361 * 0 if no parent mc in our session was found,
362 * 1 if parent mc was found and the user wants to continue,
363 * 2 if parent mc was found and the user wants to quit mc.
366 static int
367 check_sid (void)
369 pid_t my_sid, old_sid;
370 const char *sid_str;
371 int r;
373 sid_str = getenv ("MC_SID");
374 if (!sid_str)
375 return 0;
377 old_sid = (pid_t) strtol (sid_str, NULL, 0);
378 if (!old_sid)
379 return 0;
381 my_sid = getsid (0);
382 if (my_sid == -1)
383 return 0;
385 /* The parent mc is in a different session, it's OK */
386 if (old_sid != my_sid)
387 return 0;
389 r = query_dialog (_("Warning"),
390 _("GNU Midnight Commander is already\n"
391 "running on this terminal.\n"
392 "Subshell support will be disabled."), D_ERROR, 2, _("&OK"), _("&Quit"));
393 if (r != 0)
395 return 2;
398 return 1;
401 /* --------------------------------------------------------------------------------------------- */
403 static void
404 init_raw_mode ()
406 static int initialized = 0;
408 /* MC calls tty_reset_shell_mode() in pre_exec() to set the real tty to its */
409 /* original settings. However, here we need to make this tty very raw, */
410 /* so that all keyboard signals, XON/XOFF, etc. will get through to the */
411 /* pty. So, instead of changing the code for execute(), pre_exec(), */
412 /* etc, we just set up the modes we need here, before each command. */
414 if (initialized == 0) /* First time: initialise `raw_mode' */
416 tcgetattr (STDOUT_FILENO, &raw_mode);
417 raw_mode.c_lflag &= ~ICANON; /* Disable line-editing chars, etc. */
418 raw_mode.c_lflag &= ~ISIG; /* Disable intr, quit & suspend chars */
419 raw_mode.c_lflag &= ~ECHO; /* Disable input echoing */
420 raw_mode.c_iflag &= ~IXON; /* Pass ^S/^Q to subshell undisturbed */
421 raw_mode.c_iflag &= ~ICRNL; /* Don't translate CRs into LFs */
422 raw_mode.c_oflag &= ~OPOST; /* Don't postprocess output */
423 raw_mode.c_cc[VTIME] = 0; /* IE: wait forever, and return as */
424 raw_mode.c_cc[VMIN] = 1; /* soon as a character is available */
425 initialized = 1;
429 /* --------------------------------------------------------------------------------------------- */
431 * Wait until the subshell dies or stops. If it stops, make it resume.
432 * Possibly modifies the globals `subshell_alive' and `subshell_stopped'
435 static void
436 synchronize (void)
438 sigset_t sigchld_mask, old_mask;
440 sigemptyset (&sigchld_mask);
441 sigaddset (&sigchld_mask, SIGCHLD);
442 sigprocmask (SIG_BLOCK, &sigchld_mask, &old_mask);
445 * SIGCHLD should not be blocked, but we unblock it just in case.
446 * This is known to be useful for cygwin 1.3.12 and older.
448 sigdelset (&old_mask, SIGCHLD);
450 /* Wait until the subshell has stopped */
451 while (subshell_alive && !subshell_stopped)
452 sigsuspend (&old_mask);
454 if (subshell_state != ACTIVE)
456 /* Discard all remaining data from stdin to the subshell */
457 tcflush (subshell_pty_slave, TCIFLUSH);
460 subshell_stopped = FALSE;
461 kill (subshell_pid, SIGCONT);
463 sigprocmask (SIG_SETMASK, &old_mask, NULL);
464 /* We can't do any better without modifying the shell(s) */
467 /* --------------------------------------------------------------------------------------------- */
468 /** Feed the subshell our keyboard input until it says it's finished */
470 static gboolean
471 feed_subshell (int how, int fail_on_error)
473 fd_set read_set; /* For `select' */
474 int maxfdp;
475 int bytes; /* For the return value from `read' */
476 int i; /* Loop counter */
478 struct timeval wtime; /* Maximum time we wait for the subshell */
479 struct timeval *wptr;
481 /* we wait up to 10 seconds if fail_on_error, forever otherwise */
482 wtime.tv_sec = 10;
483 wtime.tv_usec = 0;
484 wptr = fail_on_error ? &wtime : NULL;
486 while (TRUE)
488 if (!subshell_alive)
489 return FALSE;
491 /* Prepare the file-descriptor set and call `select' */
493 FD_ZERO (&read_set);
494 FD_SET (mc_global.tty.subshell_pty, &read_set);
495 FD_SET (subshell_pipe[READ], &read_set);
496 maxfdp = max (mc_global.tty.subshell_pty, subshell_pipe[READ]);
497 if (how == VISIBLY)
499 FD_SET (STDIN_FILENO, &read_set);
500 maxfdp = max (maxfdp, STDIN_FILENO);
503 if (select (maxfdp + 1, &read_set, NULL, NULL, wptr) == -1)
506 /* Despite using SA_RESTART, we still have to check for this */
507 if (errno == EINTR)
508 continue; /* try all over again */
509 tcsetattr (STDOUT_FILENO, TCSANOW, &shell_mode);
510 fprintf (stderr, "select (FD_SETSIZE, &read_set...): %s\r\n",
511 unix_error_string (errno));
512 exit (EXIT_FAILURE);
515 if (FD_ISSET (mc_global.tty.subshell_pty, &read_set))
516 /* Read from the subshell, write to stdout */
518 /* This loop improves performance by reducing context switches
519 by a factor of 20 or so... unfortunately, it also hangs MC
520 randomly, because of an apparent Linux bug. Investigate. */
521 /* for (i=0; i<5; ++i) * FIXME -- experimental */
523 bytes = read (mc_global.tty.subshell_pty, pty_buffer, sizeof (pty_buffer));
525 /* The subshell has died */
526 if (bytes == -1 && errno == EIO && !subshell_alive)
527 return FALSE;
529 if (bytes <= 0)
531 tcsetattr (STDOUT_FILENO, TCSANOW, &shell_mode);
532 fprintf (stderr, "read (subshell_pty...): %s\r\n", unix_error_string (errno));
533 exit (EXIT_FAILURE);
536 if (how == VISIBLY)
537 write_all (STDOUT_FILENO, pty_buffer, bytes);
540 else if (FD_ISSET (subshell_pipe[READ], &read_set))
541 /* Read the subshell's CWD and capture its prompt */
543 bytes = read (subshell_pipe[READ], subshell_cwd, MC_MAXPATHLEN + 1);
544 if (bytes <= 0)
546 tcsetattr (STDOUT_FILENO, TCSANOW, &shell_mode);
547 fprintf (stderr, "read (subshell_pipe[READ]...): %s\r\n",
548 unix_error_string (errno));
549 exit (EXIT_FAILURE);
552 subshell_cwd[bytes - 1] = 0; /* Squash the final '\n' */
554 synchronize ();
556 subshell_ready = TRUE;
557 if (subshell_state == RUNNING_COMMAND)
559 subshell_state = INACTIVE;
560 return TRUE;
564 else if (FD_ISSET (STDIN_FILENO, &read_set))
565 /* Read from stdin, write to the subshell */
567 bytes = read (STDIN_FILENO, pty_buffer, sizeof (pty_buffer));
568 if (bytes <= 0)
570 tcsetattr (STDOUT_FILENO, TCSANOW, &shell_mode);
571 fprintf (stderr,
572 "read (STDIN_FILENO, pty_buffer...): %s\r\n", unix_error_string (errno));
573 exit (EXIT_FAILURE);
576 for (i = 0; i < bytes; ++i)
577 if (pty_buffer[i] == subshell_switch_key)
579 write_all (mc_global.tty.subshell_pty, pty_buffer, i);
580 if (subshell_ready)
581 subshell_state = INACTIVE;
582 return TRUE;
585 write_all (mc_global.tty.subshell_pty, pty_buffer, bytes);
587 if (pty_buffer[bytes - 1] == '\n' || pty_buffer[bytes - 1] == '\r')
588 subshell_ready = FALSE;
590 else
591 return FALSE;
595 /* --------------------------------------------------------------------------------------------- */
596 /* pty opening functions */
598 #ifdef HAVE_GRANTPT
600 /* System V version of pty_open_master */
602 static int
603 pty_open_master (char *pty_name)
605 char *slave_name;
606 int pty_master;
608 #ifdef HAVE_POSIX_OPENPT
609 pty_master = posix_openpt (O_RDWR);
610 #elif HAVE_GETPT
611 /* getpt () is a GNU extension (glibc 2.1.x) */
612 pty_master = getpt ();
613 #elif IS_AIX
614 strcpy (pty_name, "/dev/ptc");
615 pty_master = open (pty_name, O_RDWR);
616 #else
617 strcpy (pty_name, "/dev/ptmx");
618 pty_master = open (pty_name, O_RDWR);
619 #endif
621 if (pty_master == -1)
622 return -1;
624 if (grantpt (pty_master) == -1 /* Grant access to slave */
625 || unlockpt (pty_master) == -1 /* Clear slave's lock flag */
626 || !(slave_name = ptsname (pty_master))) /* Get slave's name */
628 close (pty_master);
629 return -1;
631 strcpy (pty_name, slave_name);
632 return pty_master;
635 /* --------------------------------------------------------------------------------------------- */
636 /** System V version of pty_open_slave */
638 static int
639 pty_open_slave (const char *pty_name)
641 int pty_slave = open (pty_name, O_RDWR);
643 if (pty_slave == -1)
645 fprintf (stderr, "open (%s, O_RDWR): %s\r\n", pty_name, unix_error_string (errno));
646 return -1;
648 #if !defined(__osf__) && !defined(__linux__)
649 #if defined (I_FIND) && defined (I_PUSH)
650 if (!ioctl (pty_slave, I_FIND, "ptem"))
651 if (ioctl (pty_slave, I_PUSH, "ptem") == -1)
653 fprintf (stderr, "ioctl (%d, I_PUSH, \"ptem\") failed: %s\r\n",
654 pty_slave, unix_error_string (errno));
655 close (pty_slave);
656 return -1;
659 if (!ioctl (pty_slave, I_FIND, "ldterm"))
660 if (ioctl (pty_slave, I_PUSH, "ldterm") == -1)
662 fprintf (stderr,
663 "ioctl (%d, I_PUSH, \"ldterm\") failed: %s\r\n",
664 pty_slave, unix_error_string (errno));
665 close (pty_slave);
666 return -1;
668 #if !defined(sgi) && !defined(__sgi)
669 if (!ioctl (pty_slave, I_FIND, "ttcompat"))
670 if (ioctl (pty_slave, I_PUSH, "ttcompat") == -1)
672 fprintf (stderr,
673 "ioctl (%d, I_PUSH, \"ttcompat\") failed: %s\r\n",
674 pty_slave, unix_error_string (errno));
675 close (pty_slave);
676 return -1;
678 #endif /* sgi || __sgi */
679 #endif /* I_FIND && I_PUSH */
680 #endif /* __osf__ || __linux__ */
682 fcntl (pty_slave, F_SETFD, FD_CLOEXEC);
683 return pty_slave;
686 #else /* !HAVE_GRANTPT */
688 /* --------------------------------------------------------------------------------------------- */
689 /** BSD version of pty_open_master */
690 static int
691 pty_open_master (char *pty_name)
693 int pty_master;
694 const char *ptr1, *ptr2;
696 strcpy (pty_name, "/dev/ptyXX");
697 for (ptr1 = "pqrstuvwxyzPQRST"; *ptr1; ++ptr1)
699 pty_name[8] = *ptr1;
700 for (ptr2 = "0123456789abcdef"; *ptr2 != '\0'; ++ptr2)
702 pty_name[9] = *ptr2;
704 /* Try to open master */
705 pty_master = open (pty_name, O_RDWR);
706 if (pty_master == -1)
708 if (errno == ENOENT) /* Different from EIO */
709 return -1; /* Out of pty devices */
710 continue; /* Try next pty device */
712 pty_name[5] = 't'; /* Change "pty" to "tty" */
713 if (access (pty_name, 6) != 0)
715 close (pty_master);
716 pty_name[5] = 'p';
717 continue;
719 return pty_master;
722 return -1; /* Ran out of pty devices */
725 /* --------------------------------------------------------------------------------------------- */
726 /** BSD version of pty_open_slave */
728 static int
729 pty_open_slave (const char *pty_name)
731 int pty_slave;
732 struct group *group_info = getgrnam ("tty");
734 if (group_info != NULL)
736 /* The following two calls will only succeed if we are root */
737 /* [Commented out while permissions problem is investigated] */
738 /* chown (pty_name, getuid (), group_info->gr_gid); FIXME */
739 /* chmod (pty_name, S_IRUSR | S_IWUSR | S_IWGRP); FIXME */
741 pty_slave = open (pty_name, O_RDWR);
742 if (pty_slave == -1)
743 fprintf (stderr, "open (pty_name, O_RDWR): %s\r\n", pty_name);
744 fcntl (pty_slave, F_SETFD, FD_CLOEXEC);
745 return pty_slave;
747 #endif /* !HAVE_GRANTPT */
749 /* --------------------------------------------------------------------------------------------- */
750 /*** public functions ****************************************************************************/
751 /* --------------------------------------------------------------------------------------------- */
753 /* --------------------------------------------------------------------------------------------- */
755 * Fork the subshell, and set up many, many things.
757 * Possibly modifies the global variables:
758 * subshell_type, subshell_alive, subshell_stopped, subshell_pid
759 * mc_global.tty.use_subshell - Is set to FALSE if we can't run the subshell
760 * quit - Can be set to SUBSHELL_EXIT by the SIGCHLD handler
763 void
764 init_subshell (void)
766 /* This must be remembered across calls to init_subshell() */
767 static char pty_name[BUF_SMALL];
768 char precmd[BUF_SMALL];
770 switch (check_sid ())
772 case 1:
773 mc_global.tty.use_subshell = FALSE;
774 return;
775 case 2:
776 mc_global.tty.use_subshell = FALSE;
777 mc_global.midnight_shutdown = TRUE;
778 return;
781 /* Take the current (hopefully pristine) tty mode and make */
782 /* a raw mode based on it now, before we do anything else with it */
783 init_raw_mode ();
785 if (mc_global.tty.subshell_pty == 0)
786 { /* First time through */
787 /* Find out what type of shell we have */
789 if (strstr (shell, "/zsh") || getenv ("ZSH_VERSION"))
790 subshell_type = ZSH;
791 else if (strstr (shell, "/tcsh"))
792 subshell_type = TCSH;
793 else if (strstr (shell, "/csh"))
794 subshell_type = TCSH;
795 else if (strstr (shell, "/bash") || getenv ("BASH"))
796 subshell_type = BASH;
797 else if (strstr (shell, "/fish"))
798 subshell_type = FISH;
799 else
801 mc_global.tty.use_subshell = FALSE;
802 return;
805 /* Open a pty for talking to the subshell */
807 /* FIXME: We may need to open a fresh pty each time on SVR4 */
809 mc_global.tty.subshell_pty = pty_open_master (pty_name);
810 if (mc_global.tty.subshell_pty == -1)
812 fprintf (stderr, "Cannot open master side of pty: %s\r\n", unix_error_string (errno));
813 mc_global.tty.use_subshell = FALSE;
814 return;
816 subshell_pty_slave = pty_open_slave (pty_name);
817 if (subshell_pty_slave == -1)
819 fprintf (stderr, "Cannot open slave side of pty %s: %s\r\n",
820 pty_name, unix_error_string (errno));
821 mc_global.tty.use_subshell = FALSE;
822 return;
825 /* Create a pipe for receiving the subshell's CWD */
827 if (subshell_type == TCSH)
829 g_snprintf (tcsh_fifo, sizeof (tcsh_fifo), "%s/mc.pipe.%d",
830 mc_tmpdir (), (int) getpid ());
831 if (mkfifo (tcsh_fifo, 0600) == -1)
833 fprintf (stderr, "mkfifo(%s) failed: %s\r\n", tcsh_fifo, unix_error_string (errno));
834 mc_global.tty.use_subshell = FALSE;
835 return;
838 /* Opening the FIFO as O_RDONLY or O_WRONLY causes deadlock */
840 if ((subshell_pipe[READ] = open (tcsh_fifo, O_RDWR)) == -1
841 || (subshell_pipe[WRITE] = open (tcsh_fifo, O_RDWR)) == -1)
843 fprintf (stderr, _("Cannot open named pipe %s\n"), tcsh_fifo);
844 perror (__FILE__ ": open");
845 mc_global.tty.use_subshell = FALSE;
846 return;
849 else /* subshell_type is BASH or ZSH */ if (pipe (subshell_pipe))
851 perror (__FILE__ ": couldn't create pipe");
852 mc_global.tty.use_subshell = FALSE;
853 return;
857 /* Fork the subshell */
859 subshell_alive = TRUE;
860 subshell_stopped = FALSE;
861 subshell_pid = fork ();
863 if (subshell_pid == -1)
865 fprintf (stderr, "Cannot spawn the subshell process: %s\r\n", unix_error_string (errno));
866 /* We exit here because, if the process table is full, the */
867 /* other method of running user commands won't work either */
868 exit (EXIT_FAILURE);
871 if (subshell_pid == 0)
873 /* We are in the child process */
874 init_subshell_child (pty_name);
877 /* Set up `precmd' or equivalent for reading the subshell's CWD */
879 switch (subshell_type)
881 case BASH:
882 g_snprintf (precmd, sizeof (precmd),
883 " PROMPT_COMMAND='pwd>&%d;kill -STOP $$'\n", subshell_pipe[WRITE]);
884 break;
886 case ZSH:
887 g_snprintf (precmd, sizeof (precmd),
888 " precmd(){ pwd>&%d;kill -STOP $$ }\n", subshell_pipe[WRITE]);
889 break;
891 case TCSH:
892 g_snprintf (precmd, sizeof (precmd),
893 "set echo_style=both;"
894 "alias precmd 'echo $cwd:q >>%s;kill -STOP $$'\n", tcsh_fifo);
895 break;
896 case FISH:
897 g_snprintf (precmd, sizeof (precmd),
898 "function fish_prompt ; pwd>&%d;kill -STOP %%self; end\n",
899 subshell_pipe[WRITE]);
900 break;
903 write_all (mc_global.tty.subshell_pty, precmd, strlen (precmd));
905 /* Wait until the subshell has started up and processed the command */
907 subshell_state = RUNNING_COMMAND;
908 tty_enable_interrupt_key ();
909 if (!feed_subshell (QUIETLY, TRUE))
911 mc_global.tty.use_subshell = FALSE;
913 tty_disable_interrupt_key ();
914 if (!subshell_alive)
915 mc_global.tty.use_subshell = FALSE; /* Subshell died instantly, so don't use it */
918 /* --------------------------------------------------------------------------------------------- */
921 invoke_subshell (const char *command, int how, char **new_dir)
923 char *pcwd;
925 /* Make the MC terminal transparent */
926 tcsetattr (STDOUT_FILENO, TCSANOW, &raw_mode);
928 /* Make the subshell change to MC's working directory */
929 if (new_dir != NULL)
930 do_subshell_chdir (current_panel->cwd, TRUE, TRUE);
932 if (command == NULL) /* The user has done "C-o" from MC */
934 if (subshell_state == INACTIVE)
936 subshell_state = ACTIVE;
937 /* FIXME: possibly take out this hack; the user can
938 re-play it by hitting C-hyphen a few times! */
939 if (subshell_ready)
940 write_all (mc_global.tty.subshell_pty, " \b", 2); /* Hack to make prompt reappear */
943 else /* MC has passed us a user command */
945 if (how == QUIETLY)
946 write_all (mc_global.tty.subshell_pty, " ", 1);
947 /* FIXME: if command is long (>8KB ?) we go comma */
948 write_all (mc_global.tty.subshell_pty, command, strlen (command));
949 write_all (mc_global.tty.subshell_pty, "\n", 1);
950 subshell_state = RUNNING_COMMAND;
951 subshell_ready = FALSE;
954 feed_subshell (how, FALSE);
956 pcwd = vfs_translate_path_n (current_panel->cwd);
957 if (new_dir && subshell_alive && strcmp (subshell_cwd, pcwd))
958 *new_dir = subshell_cwd; /* Make MC change to the subshell's CWD */
959 g_free (pcwd);
961 /* Restart the subshell if it has died by SIGHUP, SIGQUIT, etc. */
962 while (!subshell_alive && quit == 0 && mc_global.tty.use_subshell)
963 init_subshell ();
965 prompt_pos = 0;
967 return quit;
971 /* --------------------------------------------------------------------------------------------- */
974 read_subshell_prompt (void)
976 static int prompt_size = INITIAL_PROMPT_SIZE;
977 int bytes = 0, i, rc = 0;
978 struct timeval timeleft = { 0, 0 };
980 fd_set tmp;
981 FD_ZERO (&tmp);
982 FD_SET (mc_global.tty.subshell_pty, &tmp);
984 if (subshell_prompt == NULL)
985 { /* First time through */
986 subshell_prompt = g_malloc (prompt_size);
987 *subshell_prompt = '\0';
988 prompt_pos = 0;
991 while (subshell_alive
992 && (rc = select (mc_global.tty.subshell_pty + 1, &tmp, NULL, NULL, &timeleft)))
994 /* Check for `select' errors */
995 if (rc == -1)
997 if (errno == EINTR)
998 continue;
999 else
1001 fprintf (stderr, "select (FD_SETSIZE, &tmp...): %s\r\n", unix_error_string (errno));
1002 exit (EXIT_FAILURE);
1006 bytes = read (mc_global.tty.subshell_pty, pty_buffer, sizeof (pty_buffer));
1008 /* Extract the prompt from the shell output */
1010 for (i = 0; i < bytes; ++i)
1011 if (pty_buffer[i] == '\n' || pty_buffer[i] == '\r')
1013 prompt_pos = 0;
1015 else
1017 if (!pty_buffer[i])
1018 continue;
1020 subshell_prompt[prompt_pos++] = pty_buffer[i];
1021 if (prompt_pos == prompt_size)
1022 subshell_prompt = g_realloc (subshell_prompt, prompt_size *= 2);
1025 subshell_prompt[prompt_pos] = '\0';
1027 if (rc == 0 && bytes == 0)
1028 return FALSE;
1029 return TRUE;
1032 /* --------------------------------------------------------------------------------------------- */
1034 void
1035 do_update_prompt (void)
1037 if (update_subshell_prompt)
1039 printf ("\r\n%s", subshell_prompt);
1040 fflush (stdout);
1041 update_subshell_prompt = FALSE;
1045 /* --------------------------------------------------------------------------------------------- */
1048 exit_subshell (void)
1050 int subshell_quit = TRUE;
1052 if (subshell_state != INACTIVE && subshell_alive)
1053 subshell_quit =
1054 !query_dialog (_("Warning"),
1055 _("The shell is still active. Quit anyway?"),
1056 D_NORMAL, 2, _("&Yes"), _("&No"));
1058 if (subshell_quit)
1060 if (subshell_type == TCSH)
1062 if (unlink (tcsh_fifo) == -1)
1063 fprintf (stderr, "Cannot remove named pipe %s: %s\r\n",
1064 tcsh_fifo, unix_error_string (errno));
1067 g_free (subshell_prompt);
1068 subshell_prompt = NULL;
1069 pty_buffer[0] = '\0';
1072 return subshell_quit;
1075 /* --------------------------------------------------------------------------------------------- */
1077 * Carefully quote directory name to allow entering any directory safely,
1078 * no matter what weird characters it may contain in its name.
1079 * NOTE: Treat directory name an untrusted data, don't allow it to cause
1080 * executing any commands in the shell. Escape all control characters.
1081 * Use following technique:
1083 * printf(1) with format string containing a single conversion specifier,
1084 * "b", and an argument which contains a copy of the string passed to
1085 * subshell_name_quote() with all characters, except digits and letters,
1086 * replaced by the backslash-escape sequence \0nnn, where "nnn" is the
1087 * numeric value of the character converted to octal number.
1089 * cd "`printf "%b" 'ABC\0nnnDEF\0nnnXYZ'`"
1093 static char *
1094 subshell_name_quote (const char *s)
1096 char *ret, *d;
1097 const char *su, *n;
1098 const char *quote_cmd_start, *quote_cmd_end;
1099 int c;
1101 if (subshell_type == FISH)
1103 quote_cmd_start = "(printf \"%b\" '";
1104 quote_cmd_end = "')";
1106 else
1108 quote_cmd_start = "\"`printf \"%b\" '";
1109 quote_cmd_end = "'`\"";
1112 /* Factor 5 because we need \, 0 and 3 other digits per character. */
1113 d = ret = g_try_malloc (1 + (5 * strlen (s)) + (strlen (quote_cmd_start))
1114 + (strlen (quote_cmd_end)));
1115 if (d == NULL)
1116 return NULL;
1118 /* Prevent interpreting leading `-' as a switch for `cd' */
1119 if (*s == '-')
1121 *d++ = '.';
1122 *d++ = '/';
1125 /* Copy the beginning of the command to the buffer */
1126 strcpy (d, quote_cmd_start);
1127 d += strlen (quote_cmd_start);
1130 * Print every character except digits and letters as a backslash-escape
1131 * sequence of the form \0nnn, where "nnn" is the numeric value of the
1132 * character converted to octal number.
1134 su = s;
1135 for (; su[0] != '\0';)
1137 n = str_cget_next_char_safe (su);
1138 if (str_isalnum (su))
1140 memcpy (d, su, n - su);
1141 d += n - su;
1143 else
1145 for (c = 0; c < n - su; c++)
1147 sprintf (d, "\\0%03o", (unsigned char) su[c]);
1148 d += 5;
1151 su = n;
1154 strcpy (d, quote_cmd_end);
1156 return ret;
1160 /* --------------------------------------------------------------------------------------------- */
1162 /** If it actually changed the directory it returns true */
1163 void
1164 do_subshell_chdir (const char *directory, gboolean update_prompt, gboolean reset_prompt)
1166 char *pcwd;
1167 char *temp;
1168 char *translate;
1170 pcwd = vfs_translate_path_n (current_panel->cwd);
1172 if (!(subshell_state == INACTIVE && strcmp (subshell_cwd, pcwd) != 0))
1174 /* We have to repaint the subshell prompt if we read it from
1175 * the main program. Please note that in the code after this
1176 * if, the cd command that is sent will make the subshell
1177 * repaint the prompt, so we don't have to paint it. */
1178 if (update_prompt)
1179 do_update_prompt ();
1180 g_free (pcwd);
1181 return;
1184 /* The initial space keeps this out of the command history (in bash
1185 because we set "HISTCONTROL=ignorespace") */
1186 write_all (mc_global.tty.subshell_pty, " cd ", 4);
1187 if (*directory)
1189 translate = vfs_translate_path_n (directory);
1190 if (translate)
1192 temp = subshell_name_quote (translate);
1193 if (temp)
1195 write_all (mc_global.tty.subshell_pty, temp, strlen (temp));
1196 g_free (temp);
1198 else
1200 /* Should not happen unless the directory name is so long
1201 that we don't have memory to quote it. */
1202 write_all (mc_global.tty.subshell_pty, ".", 1);
1204 g_free (translate);
1206 else
1208 write_all (mc_global.tty.subshell_pty, ".", 1);
1211 else
1213 write_all (mc_global.tty.subshell_pty, "/", 1);
1215 write_all (mc_global.tty.subshell_pty, "\n", 1);
1217 subshell_state = RUNNING_COMMAND;
1218 feed_subshell (QUIETLY, FALSE);
1220 if (subshell_alive)
1222 int bPathNotEq = strcmp (subshell_cwd, pcwd);
1224 if (bPathNotEq && subshell_type == TCSH)
1226 char rp_subshell_cwd[PATH_MAX];
1227 char rp_current_panel_cwd[PATH_MAX];
1229 char *p_subshell_cwd = mc_realpath (subshell_cwd, rp_subshell_cwd);
1230 char *p_current_panel_cwd = mc_realpath (pcwd, rp_current_panel_cwd);
1232 if (p_subshell_cwd == NULL)
1233 p_subshell_cwd = subshell_cwd;
1234 if (p_current_panel_cwd == NULL)
1235 p_current_panel_cwd = pcwd;
1236 bPathNotEq = strcmp (p_subshell_cwd, p_current_panel_cwd);
1239 if (bPathNotEq && strcmp (pcwd, "."))
1241 char *cwd = strip_password (g_strdup (pcwd), 1);
1242 vfs_print_message (_("Warning: Cannot change to %s.\n"), cwd);
1243 g_free (cwd);
1247 if (reset_prompt)
1248 prompt_pos = 0;
1249 update_subshell_prompt = FALSE;
1251 g_free (pcwd);
1252 /* Make sure that MC never stores the CWD in a silly format */
1253 /* like /usr////lib/../bin, or the strcmp() above will fail */
1256 /* --------------------------------------------------------------------------------------------- */
1258 void
1259 subshell_get_console_attributes (void)
1261 /* Get our current terminal modes */
1263 if (tcgetattr (STDOUT_FILENO, &shell_mode))
1265 fprintf (stderr, "Cannot get terminal settings: %s\r\n", unix_error_string (errno));
1266 mc_global.tty.use_subshell = FALSE;
1270 /* --------------------------------------------------------------------------------------------- */
1272 * Figure out whether the subshell has stopped, exited or been killed
1273 * Possibly modifies: `subshell_alive', `subshell_stopped' and `quit' */
1275 void
1276 sigchld_handler (int sig)
1278 int status;
1279 pid_t pid;
1281 (void) sig;
1283 pid = waitpid (subshell_pid, &status, WUNTRACED | WNOHANG);
1285 if (pid == subshell_pid)
1287 /* Figure out what has happened to the subshell */
1289 if (WIFSTOPPED (status))
1291 if (WSTOPSIG (status) == SIGSTOP)
1293 /* The subshell has received a SIGSTOP signal */
1294 subshell_stopped = TRUE;
1296 else
1298 /* The user has suspended the subshell. Revive it */
1299 kill (subshell_pid, SIGCONT);
1302 else
1304 /* The subshell has either exited normally or been killed */
1305 subshell_alive = FALSE;
1306 delete_select_channel (mc_global.tty.subshell_pty);
1307 if (WIFEXITED (status) && WEXITSTATUS (status) != FORK_FAILURE)
1308 quit |= SUBSHELL_EXIT; /* Exited normally */
1311 #ifdef __linux__
1312 pid = waitpid (cons_saver_pid, &status, WUNTRACED | WNOHANG);
1314 if (pid == cons_saver_pid)
1317 if (WIFSTOPPED (status))
1318 /* Someone has stopped cons.saver - restart it */
1319 kill (pid, SIGCONT);
1320 else
1322 /* cons.saver has died - disable confole saving */
1323 handle_console (CONSOLE_DONE);
1324 mc_global.tty.console_flag = '\0';
1328 #endif /* __linux__ */
1330 /* If we got here, some other child exited; ignore it */
1333 /* --------------------------------------------------------------------------------------------- */
1335 #endif /* HAVE_SUBSHELL_SUPPORT */