2 Concurrent shell support for the Midnight Commander
4 Copyright (C) 1994, 1995, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
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/>.
25 * \brief Source: concurrent shell support
41 #include <sys/types.h>
43 #ifdef HAVE_SYS_IOCTL_H
44 #include <sys/ioctl.h>
50 #include <stropts.h> /* For I_PUSH */
51 #endif /* HAVE_STROPTS_H */
53 #include "lib/global.h"
55 #include "lib/tty/tty.h" /* LINES */
56 #include "lib/tty/key.h" /* XCTRL */
57 #include "lib/vfs/vfs.h"
58 #include "lib/strutil.h"
59 #include "lib/mcconfig.h"
61 #include "lib/widget.h"
63 #include "filemanager/midnight.h" /* current_panel */
65 #include "consaver/cons.saver.h" /* handle_console() */
69 /*** global variables ****************************************************************************/
71 /* State of the subshell:
72 * INACTIVE: the default state; awaiting a command
73 * ACTIVE: remain in the shell until the user hits `subshell_switch_key'
74 * RUNNING_COMMAND: return to MC when the current command finishes */
75 enum subshell_state_enum subshell_state
;
77 /* Holds the latest prompt captured from the subshell */
78 GString
*subshell_prompt
= NULL
;
80 /* Subshell: if set, then the prompt was not saved on CONSOLE_SAVE */
81 /* We need to paint it after CONSOLE_RESTORE, see: load_prompt */
82 gboolean update_subshell_prompt
= FALSE
;
84 /*** file scope macro definitions ****************************************************************/
87 #define WEXITSTATUS(stat_val) ((unsigned)(stat_val) >> 8)
91 #define WIFEXITED(stat_val) (((stat_val) & 255) == 0)
95 #define STDIN_FILENO 0
99 #define STDOUT_FILENO 1
102 #ifndef STDERR_FILENO
103 #define STDERR_FILENO 2
106 /* Initial length of the buffer for the subshell's prompt */
107 #define INITIAL_PROMPT_SIZE 10
109 /* Used by the child process to indicate failure to start the subshell */
110 #define FORK_FAILURE 69 /* Arbitrary */
112 /* Length of the buffer for all I/O with the subshell */
113 #define PTY_BUFFER_SIZE BUF_SMALL /* Arbitrary; but keep it >= 80 */
115 /*** file scope type declarations ****************************************************************/
124 /* Subshell type (gleaned from the SHELL environment variable, if available) */
133 /*** file scope variables ************************************************************************/
135 /* tcsh closes all non-standard file descriptors, so we have to use a pipe */
136 static char tcsh_fifo
[128];
138 static int subshell_pty_slave
= -1;
140 /* The key for switching back to MC from the subshell */
142 static const char subshell_switch_key
= XCTRL ('o') & 255;
145 /* For reading/writing on the subshell's pty */
146 static char pty_buffer
[PTY_BUFFER_SIZE
] = "\0";
148 /* To pass CWD info from the subshell to MC */
149 static int subshell_pipe
[2];
151 /* The subshell's process ID */
152 static pid_t subshell_pid
= 1;
154 /* One extra char for final '\n' */
155 static char subshell_cwd
[MC_MAXPATHLEN
+ 1];
157 /* Flag to indicate whether the subshell is ready for next command */
158 static int subshell_ready
;
160 /* The following two flags can be changed by the SIGCHLD handler. This is */
161 /* OK, because the `int' type is updated atomically on all known machines */
162 static volatile int subshell_alive
, subshell_stopped
;
164 /* We store the terminal's initial mode here so that we can configure
165 the pty similarly, and also so we can restore the real terminal to
166 sanity if we have to exit abruptly */
167 static struct termios shell_mode
;
169 /* This is a transparent mode for the terminal where MC is running on */
170 /* It is used when the shell is active, so that the control signals */
171 /* are delivered to the shell pty */
172 static struct termios raw_mode
;
174 /* This counter indicates how many characters of prompt we have read */
175 /* FIXME: try to figure out why this had to become global */
176 static int prompt_pos
;
179 /*** file scope functions ************************************************************************/
180 /* --------------------------------------------------------------------------------------------- */
182 * Write all data, even if the write() call is interrupted.
186 write_all (int fd
, const void *buf
, size_t count
)
192 ret
= write (fd
, (const unsigned char *) buf
+ written
, count
);
197 if (mc_global
.tty
.winch_flag
!= 0)
198 tty_change_screen_size ();
203 return written
> 0 ? written
: ret
;
211 /* --------------------------------------------------------------------------------------------- */
213 * Prepare child process to running the shell and run it.
215 * Modifies the global variables (in the child process only):
222 init_subshell_child (const char *pty_name
)
224 char *init_file
= NULL
;
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: */
235 ioctl (subshell_pty_slave
, TIOCSCTTY
, 0);
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 my_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 */
257 ret
= chdir (mc_config_get_home_dir ()); /* FIXME? What about when we re-run the subshell? */
261 /* Set MC_SID to prevent running one mc from another */
265 char sid_str
[BUF_SMALL
];
266 g_snprintf (sid_str
, sizeof (sid_str
), "MC_SID=%ld", (long) mc_sid
);
267 putenv (g_strdup (sid_str
));
270 switch (subshell_type
)
273 init_file
= mc_config_get_full_path ("bashrc");
275 if (access (init_file
, R_OK
) == -1)
278 init_file
= g_strdup (".bashrc");
281 /* Make MC's special commands not show up in bash's history */
282 putenv ((char *) "HISTCONTROL=ignorespace");
284 /* Allow alternative readline settings for MC */
286 char *input_file
= mc_config_get_full_path ("inputrc");
287 if (access (input_file
, R_OK
) == 0)
289 char *putenv_str
= g_strconcat ("INPUTRC=", input_file
, NULL
);
298 /* TODO: Find a way to pass initfile to TCSH and ZSH */
305 fprintf (stderr
, __FILE__
": unimplemented subshell type %d\r\n", subshell_type
);
306 my_exit (FORK_FAILURE
);
309 /* Attach all our standard file descriptors to the pty */
311 /* This is done just before the fork, because stderr must still */
312 /* be connected to the real tty during the above error messages; */
313 /* otherwise the user will never see them. */
315 dup2 (subshell_pty_slave
, STDIN_FILENO
);
316 dup2 (subshell_pty_slave
, STDOUT_FILENO
);
317 dup2 (subshell_pty_slave
, STDERR_FILENO
);
319 close (subshell_pipe
[READ
]);
320 close (subshell_pty_slave
); /* These may be FD_CLOEXEC, but just in case... */
321 /* Close master side of pty. This is important; apart from */
322 /* freeing up the descriptor for use in the subshell, it also */
323 /* means that when MC exits, the subshell will get a SIGHUP and */
324 /* exit too, because there will be no more descriptors pointing */
325 /* at the master side of the pty and so it will disappear. */
326 close (mc_global
.tty
.subshell_pty
);
328 /* Execute the subshell at last */
330 switch (subshell_type
)
333 execl (mc_global
.tty
.shell
, "bash", "-rcfile", init_file
, (char *) NULL
);
337 execl (mc_global
.tty
.shell
, "tcsh", (char *) NULL
);
341 /* Use -g to exclude cmds beginning with space from history
342 * and -Z to use the line editor on non-interactive term */
343 execl (mc_global
.tty
.shell
, "zsh", "-Z", "-g", (char *) NULL
);
348 execl (mc_global
.tty
.shell
, "fish", (char *) NULL
);
352 /* If we get this far, everything failed miserably */
354 my_exit (FORK_FAILURE
);
358 /* --------------------------------------------------------------------------------------------- */
360 * Check MC_SID to prevent running one mc from another.
362 * 0 if no parent mc in our session was found,
363 * 1 if parent mc was found and the user wants to continue,
364 * 2 if parent mc was found and the user wants to quit mc.
370 pid_t my_sid
, old_sid
;
374 sid_str
= getenv ("MC_SID");
378 old_sid
= (pid_t
) strtol (sid_str
, NULL
, 0);
386 /* The parent mc is in a different session, it's OK */
387 if (old_sid
!= my_sid
)
390 r
= query_dialog (_("Warning"),
391 _("GNU Midnight Commander is already\n"
392 "running on this terminal.\n"
393 "Subshell support will be disabled."), D_ERROR
, 2, _("&OK"), _("&Quit"));
402 /* --------------------------------------------------------------------------------------------- */
407 static int initialized
= 0;
409 /* MC calls tty_reset_shell_mode() in pre_exec() to set the real tty to its */
410 /* original settings. However, here we need to make this tty very raw, */
411 /* so that all keyboard signals, XON/XOFF, etc. will get through to the */
412 /* pty. So, instead of changing the code for execute(), pre_exec(), */
413 /* etc, we just set up the modes we need here, before each command. */
415 if (initialized
== 0) /* First time: initialise `raw_mode' */
417 tcgetattr (STDOUT_FILENO
, &raw_mode
);
418 raw_mode
.c_lflag
&= ~ICANON
; /* Disable line-editing chars, etc. */
419 raw_mode
.c_lflag
&= ~ISIG
; /* Disable intr, quit & suspend chars */
420 raw_mode
.c_lflag
&= ~ECHO
; /* Disable input echoing */
421 raw_mode
.c_iflag
&= ~IXON
; /* Pass ^S/^Q to subshell undisturbed */
422 raw_mode
.c_iflag
&= ~ICRNL
; /* Don't translate CRs into LFs */
423 raw_mode
.c_oflag
&= ~OPOST
; /* Don't postprocess output */
424 raw_mode
.c_cc
[VTIME
] = 0; /* IE: wait forever, and return as */
425 raw_mode
.c_cc
[VMIN
] = 1; /* soon as a character is available */
430 /* --------------------------------------------------------------------------------------------- */
432 * Wait until the subshell dies or stops. If it stops, make it resume.
433 * Possibly modifies the globals `subshell_alive' and `subshell_stopped'
439 sigset_t sigchld_mask
, old_mask
;
441 sigemptyset (&sigchld_mask
);
442 sigaddset (&sigchld_mask
, SIGCHLD
);
443 sigprocmask (SIG_BLOCK
, &sigchld_mask
, &old_mask
);
446 * SIGCHLD should not be blocked, but we unblock it just in case.
447 * This is known to be useful for cygwin 1.3.12 and older.
449 sigdelset (&old_mask
, SIGCHLD
);
451 /* Wait until the subshell has stopped */
452 while (subshell_alive
&& !subshell_stopped
)
453 sigsuspend (&old_mask
);
455 if (subshell_state
!= ACTIVE
)
457 /* Discard all remaining data from stdin to the subshell */
458 tcflush (subshell_pty_slave
, TCIFLUSH
);
461 subshell_stopped
= FALSE
;
462 kill (subshell_pid
, SIGCONT
);
464 sigprocmask (SIG_SETMASK
, &old_mask
, NULL
);
465 /* We can't do any better without modifying the shell(s) */
468 /* --------------------------------------------------------------------------------------------- */
469 /** Feed the subshell our keyboard input until it says it's finished */
472 feed_subshell (int how
, int fail_on_error
)
474 fd_set read_set
; /* For `select' */
476 int bytes
; /* For the return value from `read' */
477 int i
; /* Loop counter */
479 struct timeval wtime
; /* Maximum time we wait for the subshell */
480 struct timeval
*wptr
;
482 /* we wait up to 10 seconds if fail_on_error, forever otherwise */
485 wptr
= fail_on_error
? &wtime
: NULL
;
492 /* Prepare the file-descriptor set and call `select' */
495 FD_SET (mc_global
.tty
.subshell_pty
, &read_set
);
496 FD_SET (subshell_pipe
[READ
], &read_set
);
497 maxfdp
= max (mc_global
.tty
.subshell_pty
, subshell_pipe
[READ
]);
500 FD_SET (STDIN_FILENO
, &read_set
);
501 maxfdp
= max (maxfdp
, STDIN_FILENO
);
504 if (select (maxfdp
+ 1, &read_set
, NULL
, NULL
, wptr
) == -1)
506 /* Despite using SA_RESTART, we still have to check for this */
509 if (mc_global
.tty
.winch_flag
!= 0)
510 tty_change_screen_size ();
512 continue; /* try all over again */
514 tcsetattr (STDOUT_FILENO
, TCSANOW
, &shell_mode
);
515 fprintf (stderr
, "select (FD_SETSIZE, &read_set...): %s\r\n",
516 unix_error_string (errno
));
520 if (FD_ISSET (mc_global
.tty
.subshell_pty
, &read_set
))
521 /* Read from the subshell, write to stdout */
523 /* This loop improves performance by reducing context switches
524 by a factor of 20 or so... unfortunately, it also hangs MC
525 randomly, because of an apparent Linux bug. Investigate. */
526 /* for (i=0; i<5; ++i) * FIXME -- experimental */
528 bytes
= read (mc_global
.tty
.subshell_pty
, pty_buffer
, sizeof (pty_buffer
));
530 /* The subshell has died */
531 if (bytes
== -1 && errno
== EIO
&& !subshell_alive
)
536 tcsetattr (STDOUT_FILENO
, TCSANOW
, &shell_mode
);
537 fprintf (stderr
, "read (subshell_pty...): %s\r\n", unix_error_string (errno
));
542 write_all (STDOUT_FILENO
, pty_buffer
, bytes
);
545 else if (FD_ISSET (subshell_pipe
[READ
], &read_set
))
546 /* Read the subshell's CWD and capture its prompt */
548 bytes
= read (subshell_pipe
[READ
], subshell_cwd
, MC_MAXPATHLEN
+ 1);
551 tcsetattr (STDOUT_FILENO
, TCSANOW
, &shell_mode
);
552 fprintf (stderr
, "read (subshell_pipe[READ]...): %s\r\n",
553 unix_error_string (errno
));
557 subshell_cwd
[bytes
- 1] = 0; /* Squash the final '\n' */
561 subshell_ready
= TRUE
;
562 if (subshell_state
== RUNNING_COMMAND
)
564 subshell_state
= INACTIVE
;
569 else if (FD_ISSET (STDIN_FILENO
, &read_set
))
570 /* Read from stdin, write to the subshell */
572 bytes
= read (STDIN_FILENO
, pty_buffer
, sizeof (pty_buffer
));
575 tcsetattr (STDOUT_FILENO
, TCSANOW
, &shell_mode
);
577 "read (STDIN_FILENO, pty_buffer...): %s\r\n", unix_error_string (errno
));
581 for (i
= 0; i
< bytes
; ++i
)
582 if (pty_buffer
[i
] == subshell_switch_key
)
584 write_all (mc_global
.tty
.subshell_pty
, pty_buffer
, i
);
586 subshell_state
= INACTIVE
;
590 write_all (mc_global
.tty
.subshell_pty
, pty_buffer
, bytes
);
592 if (pty_buffer
[bytes
- 1] == '\n' || pty_buffer
[bytes
- 1] == '\r')
593 subshell_ready
= FALSE
;
600 /* --------------------------------------------------------------------------------------------- */
601 /* pty opening functions */
605 /* System V version of pty_open_master */
608 pty_open_master (char *pty_name
)
613 #ifdef HAVE_POSIX_OPENPT
614 pty_master
= posix_openpt (O_RDWR
);
616 /* getpt () is a GNU extension (glibc 2.1.x) */
617 pty_master
= getpt ();
619 strcpy (pty_name
, "/dev/ptc");
620 pty_master
= open (pty_name
, O_RDWR
);
622 strcpy (pty_name
, "/dev/ptmx");
623 pty_master
= open (pty_name
, O_RDWR
);
626 if (pty_master
== -1)
629 if (grantpt (pty_master
) == -1 /* Grant access to slave */
630 || unlockpt (pty_master
) == -1 /* Clear slave's lock flag */
631 || !(slave_name
= ptsname (pty_master
))) /* Get slave's name */
636 strcpy (pty_name
, slave_name
);
640 /* --------------------------------------------------------------------------------------------- */
641 /** System V version of pty_open_slave */
644 pty_open_slave (const char *pty_name
)
646 int pty_slave
= open (pty_name
, O_RDWR
);
650 fprintf (stderr
, "open (%s, O_RDWR): %s\r\n", pty_name
, unix_error_string (errno
));
653 #if !defined(__osf__) && !defined(__linux__)
654 #if defined (I_FIND) && defined (I_PUSH)
655 if (!ioctl (pty_slave
, I_FIND
, "ptem"))
656 if (ioctl (pty_slave
, I_PUSH
, "ptem") == -1)
658 fprintf (stderr
, "ioctl (%d, I_PUSH, \"ptem\") failed: %s\r\n",
659 pty_slave
, unix_error_string (errno
));
664 if (!ioctl (pty_slave
, I_FIND
, "ldterm"))
665 if (ioctl (pty_slave
, I_PUSH
, "ldterm") == -1)
668 "ioctl (%d, I_PUSH, \"ldterm\") failed: %s\r\n",
669 pty_slave
, unix_error_string (errno
));
673 #if !defined(sgi) && !defined(__sgi)
674 if (!ioctl (pty_slave
, I_FIND
, "ttcompat"))
675 if (ioctl (pty_slave
, I_PUSH
, "ttcompat") == -1)
678 "ioctl (%d, I_PUSH, \"ttcompat\") failed: %s\r\n",
679 pty_slave
, unix_error_string (errno
));
683 #endif /* sgi || __sgi */
684 #endif /* I_FIND && I_PUSH */
685 #endif /* __osf__ || __linux__ */
687 fcntl (pty_slave
, F_SETFD
, FD_CLOEXEC
);
691 #else /* !HAVE_GRANTPT */
693 /* --------------------------------------------------------------------------------------------- */
694 /** BSD version of pty_open_master */
696 pty_open_master (char *pty_name
)
699 const char *ptr1
, *ptr2
;
701 strcpy (pty_name
, "/dev/ptyXX");
702 for (ptr1
= "pqrstuvwxyzPQRST"; *ptr1
; ++ptr1
)
705 for (ptr2
= "0123456789abcdef"; *ptr2
!= '\0'; ++ptr2
)
709 /* Try to open master */
710 pty_master
= open (pty_name
, O_RDWR
);
711 if (pty_master
== -1)
713 if (errno
== ENOENT
) /* Different from EIO */
714 return -1; /* Out of pty devices */
715 continue; /* Try next pty device */
717 pty_name
[5] = 't'; /* Change "pty" to "tty" */
718 if (access (pty_name
, 6) != 0)
727 return -1; /* Ran out of pty devices */
730 /* --------------------------------------------------------------------------------------------- */
731 /** BSD version of pty_open_slave */
734 pty_open_slave (const char *pty_name
)
737 struct group
*group_info
= getgrnam ("tty");
739 if (group_info
!= NULL
)
741 /* The following two calls will only succeed if we are root */
742 /* [Commented out while permissions problem is investigated] */
743 /* chown (pty_name, getuid (), group_info->gr_gid); FIXME */
744 /* chmod (pty_name, S_IRUSR | S_IWUSR | S_IWGRP); FIXME */
746 pty_slave
= open (pty_name
, O_RDWR
);
748 fprintf (stderr
, "open (pty_name, O_RDWR): %s\r\n", pty_name
);
749 fcntl (pty_slave
, F_SETFD
, FD_CLOEXEC
);
752 #endif /* !HAVE_GRANTPT */
754 /* --------------------------------------------------------------------------------------------- */
755 /*** public functions ****************************************************************************/
756 /* --------------------------------------------------------------------------------------------- */
758 /* --------------------------------------------------------------------------------------------- */
760 * Fork the subshell, and set up many, many things.
762 * Possibly modifies the global variables:
763 * subshell_type, subshell_alive, subshell_stopped, subshell_pid
764 * mc_global.tty.use_subshell - Is set to FALSE if we can't run the subshell
765 * quit - Can be set to SUBSHELL_EXIT by the SIGCHLD handler
771 /* This must be remembered across calls to init_subshell() */
772 static char pty_name
[BUF_SMALL
];
773 char precmd
[BUF_SMALL
];
775 switch (check_sid ())
778 mc_global
.tty
.use_subshell
= FALSE
;
781 mc_global
.tty
.use_subshell
= FALSE
;
782 mc_global
.midnight_shutdown
= TRUE
;
786 /* Take the current (hopefully pristine) tty mode and make */
787 /* a raw mode based on it now, before we do anything else with it */
790 if (mc_global
.tty
.subshell_pty
== 0)
791 { /* First time through */
792 /* Find out what type of shell we have */
794 if (strstr (mc_global
.tty
.shell
, "/zsh") || getenv ("ZSH_VERSION"))
796 else if (strstr (mc_global
.tty
.shell
, "/tcsh"))
797 subshell_type
= TCSH
;
798 else if (strstr (mc_global
.tty
.shell
, "/csh"))
799 subshell_type
= TCSH
;
800 else if (strstr (mc_global
.tty
.shell
, "/bash") || getenv ("BASH"))
801 subshell_type
= BASH
;
802 else if (strstr (mc_global
.tty
.shell
, "/fish"))
803 subshell_type
= FISH
;
806 mc_global
.tty
.use_subshell
= FALSE
;
810 /* Open a pty for talking to the subshell */
812 /* FIXME: We may need to open a fresh pty each time on SVR4 */
814 mc_global
.tty
.subshell_pty
= pty_open_master (pty_name
);
815 if (mc_global
.tty
.subshell_pty
== -1)
817 fprintf (stderr
, "Cannot open master side of pty: %s\r\n", unix_error_string (errno
));
818 mc_global
.tty
.use_subshell
= FALSE
;
821 subshell_pty_slave
= pty_open_slave (pty_name
);
822 if (subshell_pty_slave
== -1)
824 fprintf (stderr
, "Cannot open slave side of pty %s: %s\r\n",
825 pty_name
, unix_error_string (errno
));
826 mc_global
.tty
.use_subshell
= FALSE
;
830 /* Create a pipe for receiving the subshell's CWD */
832 if (subshell_type
== TCSH
)
834 g_snprintf (tcsh_fifo
, sizeof (tcsh_fifo
), "%s/mc.pipe.%d",
835 mc_tmpdir (), (int) getpid ());
836 if (mkfifo (tcsh_fifo
, 0600) == -1)
838 fprintf (stderr
, "mkfifo(%s) failed: %s\r\n", tcsh_fifo
, unix_error_string (errno
));
839 mc_global
.tty
.use_subshell
= FALSE
;
843 /* Opening the FIFO as O_RDONLY or O_WRONLY causes deadlock */
845 if ((subshell_pipe
[READ
] = open (tcsh_fifo
, O_RDWR
)) == -1
846 || (subshell_pipe
[WRITE
] = open (tcsh_fifo
, O_RDWR
)) == -1)
848 fprintf (stderr
, _("Cannot open named pipe %s\n"), tcsh_fifo
);
849 perror (__FILE__
": open");
850 mc_global
.tty
.use_subshell
= FALSE
;
854 else /* subshell_type is BASH or ZSH */ if (pipe (subshell_pipe
))
856 perror (__FILE__
": couldn't create pipe");
857 mc_global
.tty
.use_subshell
= FALSE
;
862 /* Fork the subshell */
864 subshell_alive
= TRUE
;
865 subshell_stopped
= FALSE
;
866 subshell_pid
= fork ();
868 if (subshell_pid
== -1)
870 fprintf (stderr
, "Cannot spawn the subshell process: %s\r\n", unix_error_string (errno
));
871 /* We exit here because, if the process table is full, the */
872 /* other method of running user commands won't work either */
876 if (subshell_pid
== 0)
878 /* We are in the child process */
879 init_subshell_child (pty_name
);
882 /* Set up `precmd' or equivalent for reading the subshell's CWD */
884 switch (subshell_type
)
887 g_snprintf (precmd
, sizeof (precmd
),
888 " PROMPT_COMMAND='pwd>&%d;kill -STOP $$'\n", subshell_pipe
[WRITE
]);
892 g_snprintf (precmd
, sizeof (precmd
),
893 " precmd(){ pwd>&%d;kill -STOP $$ }\n", subshell_pipe
[WRITE
]);
897 g_snprintf (precmd
, sizeof (precmd
),
898 "set echo_style=both;"
899 "alias precmd 'echo $cwd:q >>%s;kill -STOP $$'\n", tcsh_fifo
);
902 g_snprintf (precmd
, sizeof (precmd
),
903 "function fish_prompt ; pwd>&%d;kill -STOP %%self; end\n",
904 subshell_pipe
[WRITE
]);
908 write_all (mc_global
.tty
.subshell_pty
, precmd
, strlen (precmd
));
910 /* Wait until the subshell has started up and processed the command */
912 subshell_state
= RUNNING_COMMAND
;
913 tty_enable_interrupt_key ();
914 if (!feed_subshell (QUIETLY
, TRUE
))
916 mc_global
.tty
.use_subshell
= FALSE
;
918 tty_disable_interrupt_key ();
920 mc_global
.tty
.use_subshell
= FALSE
; /* Subshell died instantly, so don't use it */
923 /* --------------------------------------------------------------------------------------------- */
926 invoke_subshell (const char *command
, int how
, vfs_path_t
** new_dir_vpath
)
930 /* Make the MC terminal transparent */
931 tcsetattr (STDOUT_FILENO
, TCSANOW
, &raw_mode
);
933 /* Make the subshell change to MC's working directory */
934 if (new_dir_vpath
!= NULL
)
935 do_subshell_chdir (current_panel
->cwd_vpath
, TRUE
, TRUE
);
937 if (command
== NULL
) /* The user has done "C-o" from MC */
939 if (subshell_state
== INACTIVE
)
941 subshell_state
= ACTIVE
;
942 /* FIXME: possibly take out this hack; the user can
943 re-play it by hitting C-hyphen a few times! */
945 write_all (mc_global
.tty
.subshell_pty
, " \b", 2); /* Hack to make prompt reappear */
948 else /* MC has passed us a user command */
951 write_all (mc_global
.tty
.subshell_pty
, " ", 1);
952 /* FIXME: if command is long (>8KB ?) we go comma */
953 write_all (mc_global
.tty
.subshell_pty
, command
, strlen (command
));
954 write_all (mc_global
.tty
.subshell_pty
, "\n", 1);
955 subshell_state
= RUNNING_COMMAND
;
956 subshell_ready
= FALSE
;
959 feed_subshell (how
, FALSE
);
964 cwd_str
= vfs_path_to_str (current_panel
->cwd_vpath
);
965 pcwd
= vfs_translate_path_n (cwd_str
);
969 if (new_dir_vpath
!= NULL
&& subshell_alive
&& strcmp (subshell_cwd
, pcwd
))
970 *new_dir_vpath
= vfs_path_from_str (subshell_cwd
); /* Make MC change to the subshell's CWD */
973 /* Restart the subshell if it has died by SIGHUP, SIGQUIT, etc. */
974 while (!subshell_alive
&& quit
== 0 && mc_global
.tty
.use_subshell
)
983 /* --------------------------------------------------------------------------------------------- */
986 read_subshell_prompt (void)
990 struct timeval timeleft
= { 0, 0 };
994 FD_SET (mc_global
.tty
.subshell_pty
, &tmp
);
996 /* First time through */
997 if (subshell_prompt
== NULL
)
998 subshell_prompt
= g_string_sized_new (INITIAL_PROMPT_SIZE
);
1000 while (subshell_alive
1001 && (rc
= select (mc_global
.tty
.subshell_pty
+ 1, &tmp
, NULL
, NULL
, &timeleft
)) != 0)
1005 /* Check for `select' errors */
1010 if (mc_global
.tty
.winch_flag
!= 0)
1011 tty_change_screen_size ();
1016 fprintf (stderr
, "select (FD_SETSIZE, &tmp...): %s\r\n", unix_error_string (errno
));
1017 exit (EXIT_FAILURE
);
1020 bytes
= read (mc_global
.tty
.subshell_pty
, pty_buffer
, sizeof (pty_buffer
));
1022 /* Extract the prompt from the shell output */
1023 g_string_set_size (subshell_prompt
, 0);
1024 for (i
= 0; i
< bytes
; i
++)
1025 if (pty_buffer
[i
] == '\n' || pty_buffer
[i
] == '\r')
1026 g_string_set_size (subshell_prompt
, 0);
1027 else if (pty_buffer
[i
] != '\0')
1028 g_string_append_c (subshell_prompt
, pty_buffer
[i
]);
1031 return (rc
!= 0 || bytes
!= 0);
1034 /* --------------------------------------------------------------------------------------------- */
1037 do_update_prompt (void)
1039 if (update_subshell_prompt
)
1041 printf ("\r\n%s", subshell_prompt
->str
);
1043 update_subshell_prompt
= FALSE
;
1047 /* --------------------------------------------------------------------------------------------- */
1050 exit_subshell (void)
1052 gboolean subshell_quit
= TRUE
;
1054 if (subshell_state
!= INACTIVE
&& subshell_alive
)
1056 query_dialog (_("Warning"),
1057 _("The shell is still active. Quit anyway?"),
1058 D_NORMAL
, 2, _("&Yes"), _("&No")) == 0;
1062 if (subshell_type
== TCSH
)
1064 if (unlink (tcsh_fifo
) == -1)
1065 fprintf (stderr
, "Cannot remove named pipe %s: %s\r\n",
1066 tcsh_fifo
, unix_error_string (errno
));
1069 g_string_free (subshell_prompt
, TRUE
);
1070 subshell_prompt
= NULL
;
1071 pty_buffer
[0] = '\0';
1074 return subshell_quit
;
1077 /* --------------------------------------------------------------------------------------------- */
1079 * Carefully quote directory name to allow entering any directory safely,
1080 * no matter what weird characters it may contain in its name.
1081 * NOTE: Treat directory name an untrusted data, don't allow it to cause
1082 * executing any commands in the shell. Escape all control characters.
1083 * Use following technique:
1085 * printf(1) with format string containing a single conversion specifier,
1086 * "b", and an argument which contains a copy of the string passed to
1087 * subshell_name_quote() with all characters, except digits and letters,
1088 * replaced by the backslash-escape sequence \0nnn, where "nnn" is the
1089 * numeric value of the character converted to octal number.
1091 * cd "`printf "%b" 'ABC\0nnnDEF\0nnnXYZ'`"
1096 subshell_name_quote (const char *s
)
1100 const char *quote_cmd_start
, *quote_cmd_end
;
1103 if (subshell_type
== FISH
)
1105 quote_cmd_start
= "(printf \"%b\" '";
1106 quote_cmd_end
= "')";
1110 quote_cmd_start
= "\"`printf \"%b\" '";
1111 quote_cmd_end
= "'`\"";
1114 /* Factor 5 because we need \, 0 and 3 other digits per character. */
1115 d
= ret
= g_try_malloc (1 + (5 * strlen (s
)) + (strlen (quote_cmd_start
))
1116 + (strlen (quote_cmd_end
)));
1120 /* Prevent interpreting leading `-' as a switch for `cd' */
1127 /* Copy the beginning of the command to the buffer */
1128 strcpy (d
, quote_cmd_start
);
1129 d
+= strlen (quote_cmd_start
);
1132 * Print every character except digits and letters as a backslash-escape
1133 * sequence of the form \0nnn, where "nnn" is the numeric value of the
1134 * character converted to octal number.
1137 for (; su
[0] != '\0';)
1139 n
= str_cget_next_char_safe (su
);
1140 if (str_isalnum (su
))
1142 memcpy (d
, su
, n
- su
);
1147 for (c
= 0; c
< n
- su
; c
++)
1149 sprintf (d
, "\\0%03o", (unsigned char) su
[c
]);
1156 strcpy (d
, quote_cmd_end
);
1162 /* --------------------------------------------------------------------------------------------- */
1164 /** If it actually changed the directory it returns true */
1166 do_subshell_chdir (const vfs_path_t
* vpath
, gboolean update_prompt
, gboolean reset_prompt
)
1172 pcwd
= vfs_path_to_str_flags (current_panel
->cwd_vpath
, 0, VPF_RECODE
);
1174 if (!(subshell_state
== INACTIVE
&& strcmp (subshell_cwd
, pcwd
) != 0))
1176 /* We have to repaint the subshell prompt if we read it from
1177 * the main program. Please note that in the code after this
1178 * if, the cd command that is sent will make the subshell
1179 * repaint the prompt, so we don't have to paint it. */
1181 do_update_prompt ();
1186 /* The initial space keeps this out of the command history (in bash
1187 because we set "HISTCONTROL=ignorespace") */
1188 write_all (mc_global
.tty
.subshell_pty
, " cd ", 4);
1190 directory
= vfs_path_to_str (vpath
);
1191 if (directory
!= '\0')
1195 translate
= vfs_translate_path_n (directory
);
1196 if (translate
!= NULL
)
1198 temp
= subshell_name_quote (translate
);
1201 write_all (mc_global
.tty
.subshell_pty
, temp
, strlen (temp
));
1206 /* Should not happen unless the directory name is so long
1207 that we don't have memory to quote it. */
1208 write_all (mc_global
.tty
.subshell_pty
, ".", 1);
1214 write_all (mc_global
.tty
.subshell_pty
, ".", 1);
1219 write_all (mc_global
.tty
.subshell_pty
, "/", 1);
1222 write_all (mc_global
.tty
.subshell_pty
, "\n", 1);
1224 subshell_state
= RUNNING_COMMAND
;
1225 feed_subshell (QUIETLY
, FALSE
);
1229 int bPathNotEq
= strcmp (subshell_cwd
, pcwd
);
1231 if (bPathNotEq
&& subshell_type
== TCSH
)
1233 char rp_subshell_cwd
[PATH_MAX
];
1234 char rp_current_panel_cwd
[PATH_MAX
];
1236 char *p_subshell_cwd
= mc_realpath (subshell_cwd
, rp_subshell_cwd
);
1237 char *p_current_panel_cwd
= mc_realpath (pcwd
, rp_current_panel_cwd
);
1239 if (p_subshell_cwd
== NULL
)
1240 p_subshell_cwd
= subshell_cwd
;
1241 if (p_current_panel_cwd
== NULL
)
1242 p_current_panel_cwd
= pcwd
;
1243 bPathNotEq
= strcmp (p_subshell_cwd
, p_current_panel_cwd
);
1246 if (bPathNotEq
&& strcmp (pcwd
, ".") != 0)
1250 cwd
= vfs_path_to_str_flags (current_panel
->cwd_vpath
, 0, VPF_STRIP_PASSWORD
);
1251 vfs_print_message (_("Warning: Cannot change to %s.\n"), cwd
);
1258 update_subshell_prompt
= FALSE
;
1261 /* Make sure that MC never stores the CWD in a silly format */
1262 /* like /usr////lib/../bin, or the strcmp() above will fail */
1265 /* --------------------------------------------------------------------------------------------- */
1268 subshell_get_console_attributes (void)
1270 /* Get our current terminal modes */
1272 if (tcgetattr (STDOUT_FILENO
, &shell_mode
))
1274 fprintf (stderr
, "Cannot get terminal settings: %s\r\n", unix_error_string (errno
));
1275 mc_global
.tty
.use_subshell
= FALSE
;
1279 /* --------------------------------------------------------------------------------------------- */
1281 * Figure out whether the subshell has stopped, exited or been killed
1282 * Possibly modifies: `subshell_alive', `subshell_stopped' and `quit' */
1285 sigchld_handler (int sig
)
1292 pid
= waitpid (subshell_pid
, &status
, WUNTRACED
| WNOHANG
);
1294 if (pid
== subshell_pid
)
1296 /* Figure out what has happened to the subshell */
1298 if (WIFSTOPPED (status
))
1300 if (WSTOPSIG (status
) == SIGSTOP
)
1302 /* The subshell has received a SIGSTOP signal */
1303 subshell_stopped
= TRUE
;
1307 /* The user has suspended the subshell. Revive it */
1308 kill (subshell_pid
, SIGCONT
);
1313 /* The subshell has either exited normally or been killed */
1314 subshell_alive
= FALSE
;
1315 delete_select_channel (mc_global
.tty
.subshell_pty
);
1316 if (WIFEXITED (status
) && WEXITSTATUS (status
) != FORK_FAILURE
)
1317 quit
|= SUBSHELL_EXIT
; /* Exited normally */
1321 pid
= waitpid (cons_saver_pid
, &status
, WUNTRACED
| WNOHANG
);
1323 if (pid
== cons_saver_pid
)
1326 if (WIFSTOPPED (status
))
1327 /* Someone has stopped cons.saver - restart it */
1328 kill (pid
, SIGCONT
);
1331 /* cons.saver has died - disable confole saving */
1332 handle_console (CONSOLE_DONE
);
1333 mc_global
.tty
.console_flag
= '\0';
1337 #endif /* __linux__ */
1339 /* If we got here, some other child exited; ignore it */
1342 /* --------------------------------------------------------------------------------------------- */