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.
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.
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.
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.
20 * \brief Source: concurrent shell support
25 #ifdef HAVE_SUBSHELL_SUPPORT
38 #include <sys/types.h>
40 #ifdef HAVE_SYS_IOCTL_H
41 #include <sys/ioctl.h>
47 #include <stropts.h> /* For I_PUSH */
48 #endif /* HAVE_STROPTS_H */
50 #include "lib/global.h"
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/fileloc.h"
58 #include "lib/widget.h"
60 #include "filemanager/midnight.h" /* current_panel */
62 #include "main.h" /* home_dir */
63 #include "consaver/cons.saver.h" /* handle_console() */
66 /*** global variables ****************************************************************************/
68 /* If using a subshell for evaluating commands this is true */
70 #ifdef SUBSHELL_OPTIONAL
76 /* File descriptors of the pseudoterminal used by the subshell */
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
;
85 /* Holds the latest prompt captured from the subshell */
86 char *subshell_prompt
= NULL
;
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
;
92 /*** file scope macro definitions ****************************************************************/
95 #define WEXITSTATUS(stat_val) ((unsigned)(stat_val) >> 8)
99 #define WIFEXITED(stat_val) (((stat_val) & 255) == 0)
103 #define STDIN_FILENO 0
106 #ifndef STDOUT_FILENO
107 #define STDOUT_FILENO 1
110 #ifndef STDERR_FILENO
111 #define STDERR_FILENO 2
114 /* Initial length of the buffer for the subshell's prompt */
115 #define INITIAL_PROMPT_SIZE 10
117 /* Used by the child process to indicate failure to start the subshell */
118 #define FORK_FAILURE 69 /* Arbitrary */
120 /* Length of the buffer for all I/O with the subshell */
121 #define PTY_BUFFER_SIZE BUF_SMALL /* Arbitrary; but keep it >= 80 */
123 /*** file scope type declarations ****************************************************************/
132 /* Subshell type (gleaned from the SHELL environment variable, if available) */
141 /*** file scope variables ************************************************************************/
143 /* tcsh closes all non-standard file descriptors, so we have to use a pipe */
144 static char tcsh_fifo
[128];
146 static int subshell_pty_slave
= -1;
148 /* The key for switching back to MC from the subshell */
150 static const char subshell_switch_key
= XCTRL ('o') & 255;
153 /* For reading/writing on the subshell's pty */
154 static char pty_buffer
[PTY_BUFFER_SIZE
] = "\0";
156 /* To pass CWD info from the subshell to MC */
157 static int subshell_pipe
[2];
159 /* The subshell's process ID */
160 static pid_t subshell_pid
= 1;
162 /* One extra char for final '\n' */
163 static char subshell_cwd
[MC_MAXPATHLEN
+ 1];
165 /* Flag to indicate whether the subshell is ready for next command */
166 static int subshell_ready
;
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
;
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
;
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
;
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
;
187 /*** file scope functions ************************************************************************/
188 /* --------------------------------------------------------------------------------------------- */
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
);
197 /* --------------------------------------------------------------------------------------------- */
199 * Write all data, even if the write() call is interrupted.
203 write_all (int fd
, const void *buf
, size_t count
)
209 ret
= write (fd
, (const unsigned char *) buf
+ written
, count
);
218 return written
> 0 ? written
: ret
;
227 /* --------------------------------------------------------------------------------------------- */
229 * Prepare child process to running the shell and run it.
231 * Modifies the global variables (in the child process only):
238 init_subshell_child (const char *pty_name
)
240 const char *init_file
= NULL
;
244 setsid (); /* Get a fresh terminal session */
246 /* Make sure that it has become our controlling terminal */
248 /* Redundant on Linux and probably most systems, but just in case: */
251 ioctl (subshell_pty_slave
, TIOCSCTTY
, 0);
254 /* Configure its terminal modes and window size */
256 /* Set up the pty with the same termios flags as our own tty */
257 if (tcsetattr (subshell_pty_slave
, TCSANOW
, &shell_mode
))
259 fprintf (stderr
, "Cannot set pty terminal modes: %s\r\n", unix_error_string (errno
));
260 _exit (FORK_FAILURE
);
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
);
267 /* Set up the subshell's environment and init file name */
269 /* It simplifies things to change to our home directory here, */
270 /* and the user's startup file may do a `cd' command anyway */
273 ret
= chdir (home_dir
); /* FIXME? What about when we re-run the subshell? */
276 /* Set MC_SID to prevent running one mc from another */
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
));
285 switch (subshell_type
)
288 init_file
= MC_USERCONF_DIR PATH_SEP_STR
"bashrc";
289 if (access (init_file
, R_OK
) == -1)
290 init_file
= ".bashrc";
292 /* Make MC's special commands not show up in bash's history */
293 putenv ((char *) "HISTCONTROL=ignorespace");
295 /* Allow alternative readline settings for MC */
296 if (access (MC_USERCONF_DIR PATH_SEP_STR
"inputrc", R_OK
) == 0)
297 putenv ((char *) "INPUTRC=" MC_USERCONF_DIR PATH_SEP_STR
"/inputrc");
301 /* TODO: Find a way to pass initfile to TCSH and ZSH */
308 fprintf (stderr
, __FILE__
": unimplemented subshell type %d\r\n", subshell_type
);
309 _exit (FORK_FAILURE
);
312 /* Attach all our standard file descriptors to the pty */
314 /* This is done just before the fork, because stderr must still */
315 /* be connected to the real tty during the above error messages; */
316 /* otherwise the user will never see them. */
318 dup2 (subshell_pty_slave
, STDIN_FILENO
);
319 dup2 (subshell_pty_slave
, STDOUT_FILENO
);
320 dup2 (subshell_pty_slave
, STDERR_FILENO
);
322 close (subshell_pipe
[READ
]);
323 close (subshell_pty_slave
); /* These may be FD_CLOEXEC, but just in case... */
324 /* Close master side of pty. This is important; apart from */
325 /* freeing up the descriptor for use in the subshell, it also */
326 /* means that when MC exits, the subshell will get a SIGHUP and */
327 /* exit too, because there will be no more descriptors pointing */
328 /* at the master side of the pty and so it will disappear. */
329 close (subshell_pty
);
331 /* Execute the subshell at last */
333 switch (subshell_type
)
336 execl (shell
, "bash", "-rcfile", init_file
, (char *) NULL
);
340 execl (shell
, "tcsh", (char *) NULL
);
344 /* Use -g to exclude cmds beginning with space from history
345 * and -Z to use the line editor on non-interactive term */
346 execl (shell
, "zsh", "-Z", "-g", (char *) NULL
);
351 execl (shell
, "fish", (char *) NULL
);
355 /* If we get this far, everything failed miserably */
356 _exit (FORK_FAILURE
);
360 /* --------------------------------------------------------------------------------------------- */
362 * Check MC_SID to prevent running one mc from another.
364 * 0 if no parent mc in our session was found,
365 * 1 if parent mc was found and the user wants to continue,
366 * 2 if parent mc was found and the user wants to quit mc.
372 pid_t my_sid
, old_sid
;
376 sid_str
= getenv ("MC_SID");
380 old_sid
= (pid_t
) strtol (sid_str
, NULL
, 0);
388 /* The parent mc is in a different session, it's OK */
389 if (old_sid
!= my_sid
)
392 r
= query_dialog (_("Warning"),
393 _("GNU Midnight Commander is already\n"
394 "running on this terminal.\n"
395 "Subshell support will be disabled."), D_ERROR
, 2, _("&OK"), _("&Quit"));
404 /* --------------------------------------------------------------------------------------------- */
409 static int initialized
= 0;
411 /* MC calls tty_reset_shell_mode() in pre_exec() to set the real tty to its */
412 /* original settings. However, here we need to make this tty very raw, */
413 /* so that all keyboard signals, XON/XOFF, etc. will get through to the */
414 /* pty. So, instead of changing the code for execute(), pre_exec(), */
415 /* etc, we just set up the modes we need here, before each command. */
417 if (initialized
== 0) /* First time: initialise `raw_mode' */
419 tcgetattr (STDOUT_FILENO
, &raw_mode
);
420 raw_mode
.c_lflag
&= ~ICANON
; /* Disable line-editing chars, etc. */
421 raw_mode
.c_lflag
&= ~ISIG
; /* Disable intr, quit & suspend chars */
422 raw_mode
.c_lflag
&= ~ECHO
; /* Disable input echoing */
423 raw_mode
.c_iflag
&= ~IXON
; /* Pass ^S/^Q to subshell undisturbed */
424 raw_mode
.c_iflag
&= ~ICRNL
; /* Don't translate CRs into LFs */
425 raw_mode
.c_oflag
&= ~OPOST
; /* Don't postprocess output */
426 raw_mode
.c_cc
[VTIME
] = 0; /* IE: wait forever, and return as */
427 raw_mode
.c_cc
[VMIN
] = 1; /* soon as a character is available */
432 /* --------------------------------------------------------------------------------------------- */
433 /** Feed the subshell our keyboard input until it says it's finished */
436 feed_subshell (int how
, int fail_on_error
)
438 fd_set read_set
; /* For `select' */
440 int bytes
; /* For the return value from `read' */
441 int i
; /* Loop counter */
443 struct timeval wtime
; /* Maximum time we wait for the subshell */
444 struct timeval
*wptr
;
446 /* we wait up to 10 seconds if fail_on_error, forever otherwise */
449 wptr
= fail_on_error
? &wtime
: NULL
;
456 /* Prepare the file-descriptor set and call `select' */
459 FD_SET (subshell_pty
, &read_set
);
460 FD_SET (subshell_pipe
[READ
], &read_set
);
461 maxfdp
= max (subshell_pty
, subshell_pipe
[READ
]);
464 FD_SET (STDIN_FILENO
, &read_set
);
465 maxfdp
= max (maxfdp
, STDIN_FILENO
);
468 if (select (maxfdp
+ 1, &read_set
, NULL
, NULL
, wptr
) == -1)
471 /* Despite using SA_RESTART, we still have to check for this */
473 continue; /* try all over again */
474 tcsetattr (STDOUT_FILENO
, TCSANOW
, &shell_mode
);
475 fprintf (stderr
, "select (FD_SETSIZE, &read_set...): %s\r\n",
476 unix_error_string (errno
));
480 if (FD_ISSET (subshell_pty
, &read_set
))
481 /* Read from the subshell, write to stdout */
483 /* This loop improves performance by reducing context switches
484 by a factor of 20 or so... unfortunately, it also hangs MC
485 randomly, because of an apparent Linux bug. Investigate. */
486 /* for (i=0; i<5; ++i) * FIXME -- experimental */
488 bytes
= read (subshell_pty
, pty_buffer
, sizeof (pty_buffer
));
490 /* The subshell has died */
491 if (bytes
== -1 && errno
== EIO
&& !subshell_alive
)
496 tcsetattr (STDOUT_FILENO
, TCSANOW
, &shell_mode
);
497 fprintf (stderr
, "read (subshell_pty...): %s\r\n", unix_error_string (errno
));
502 write_all (STDOUT_FILENO
, pty_buffer
, bytes
);
505 else if (FD_ISSET (subshell_pipe
[READ
], &read_set
))
506 /* Read the subshell's CWD and capture its prompt */
508 bytes
= read (subshell_pipe
[READ
], subshell_cwd
, MC_MAXPATHLEN
+ 1);
511 tcsetattr (STDOUT_FILENO
, TCSANOW
, &shell_mode
);
512 fprintf (stderr
, "read (subshell_pipe[READ]...): %s\r\n",
513 unix_error_string (errno
));
517 subshell_cwd
[bytes
- 1] = 0; /* Squash the final '\n' */
521 subshell_ready
= TRUE
;
522 if (subshell_state
== RUNNING_COMMAND
)
524 subshell_state
= INACTIVE
;
529 else if (FD_ISSET (STDIN_FILENO
, &read_set
))
530 /* Read from stdin, write to the subshell */
532 bytes
= read (STDIN_FILENO
, pty_buffer
, sizeof (pty_buffer
));
535 tcsetattr (STDOUT_FILENO
, TCSANOW
, &shell_mode
);
537 "read (STDIN_FILENO, pty_buffer...): %s\r\n", unix_error_string (errno
));
541 for (i
= 0; i
< bytes
; ++i
)
542 if (pty_buffer
[i
] == subshell_switch_key
)
544 write_all (subshell_pty
, pty_buffer
, i
);
546 subshell_state
= INACTIVE
;
550 write_all (subshell_pty
, pty_buffer
, bytes
);
552 if (pty_buffer
[bytes
- 1] == '\n' || pty_buffer
[bytes
- 1] == '\r')
553 subshell_ready
= FALSE
;
560 /* --------------------------------------------------------------------------------------------- */
562 * Wait until the subshell dies or stops. If it stops, make it resume.
563 * Possibly modifies the globals `subshell_alive' and `subshell_stopped'
569 sigset_t sigchld_mask
, old_mask
;
571 sigemptyset (&sigchld_mask
);
572 sigaddset (&sigchld_mask
, SIGCHLD
);
573 sigprocmask (SIG_BLOCK
, &sigchld_mask
, &old_mask
);
576 * SIGCHLD should not be blocked, but we unblock it just in case.
577 * This is known to be useful for cygwin 1.3.12 and older.
579 sigdelset (&old_mask
, SIGCHLD
);
581 /* Wait until the subshell has stopped */
582 while (subshell_alive
&& !subshell_stopped
)
583 sigsuspend (&old_mask
);
585 if (subshell_state
!= ACTIVE
)
587 /* Discard all remaining data from stdin to the subshell */
588 tcflush (subshell_pty_slave
, TCIFLUSH
);
591 subshell_stopped
= FALSE
;
592 kill (subshell_pid
, SIGCONT
);
594 sigprocmask (SIG_SETMASK
, &old_mask
, NULL
);
595 /* We can't do any better without modifying the shell(s) */
598 /* pty opening functions */
602 /* System V version of pty_open_master */
605 pty_open_master (char *pty_name
)
610 #ifdef HAVE_POSIX_OPENPT
611 pty_master
= posix_openpt (O_RDWR
);
613 /* getpt () is a GNU extension (glibc 2.1.x) */
614 pty_master
= getpt ();
616 strcpy (pty_name
, "/dev/ptc");
617 pty_master
= open (pty_name
, O_RDWR
);
619 strcpy (pty_name
, "/dev/ptmx");
620 pty_master
= open (pty_name
, O_RDWR
);
623 if (pty_master
== -1)
626 if (grantpt (pty_master
) == -1 /* Grant access to slave */
627 || unlockpt (pty_master
) == -1 /* Clear slave's lock flag */
628 || !(slave_name
= ptsname (pty_master
))) /* Get slave's name */
633 strcpy (pty_name
, slave_name
);
637 /* --------------------------------------------------------------------------------------------- */
638 /** System V version of pty_open_slave */
641 pty_open_slave (const char *pty_name
)
643 int pty_slave
= open (pty_name
, O_RDWR
);
647 fprintf (stderr
, "open (%s, O_RDWR): %s\r\n", pty_name
, unix_error_string (errno
));
650 #if !defined(__osf__) && !defined(__linux__)
651 #if defined (I_FIND) && defined (I_PUSH)
652 if (!ioctl (pty_slave
, I_FIND
, "ptem"))
653 if (ioctl (pty_slave
, I_PUSH
, "ptem") == -1)
655 fprintf (stderr
, "ioctl (%d, I_PUSH, \"ptem\") failed: %s\r\n",
656 pty_slave
, unix_error_string (errno
));
661 if (!ioctl (pty_slave
, I_FIND
, "ldterm"))
662 if (ioctl (pty_slave
, I_PUSH
, "ldterm") == -1)
665 "ioctl (%d, I_PUSH, \"ldterm\") failed: %s\r\n",
666 pty_slave
, unix_error_string (errno
));
670 #if !defined(sgi) && !defined(__sgi)
671 if (!ioctl (pty_slave
, I_FIND
, "ttcompat"))
672 if (ioctl (pty_slave
, I_PUSH
, "ttcompat") == -1)
675 "ioctl (%d, I_PUSH, \"ttcompat\") failed: %s\r\n",
676 pty_slave
, unix_error_string (errno
));
680 #endif /* sgi || __sgi */
681 #endif /* I_FIND && I_PUSH */
682 #endif /* __osf__ || __linux__ */
684 fcntl (pty_slave
, F_SETFD
, FD_CLOEXEC
);
688 #else /* !HAVE_GRANTPT */
690 /* --------------------------------------------------------------------------------------------- */
691 /** BSD version of pty_open_master */
693 pty_open_master (char *pty_name
)
696 const char *ptr1
, *ptr2
;
698 strcpy (pty_name
, "/dev/ptyXX");
699 for (ptr1
= "pqrstuvwxyzPQRST"; *ptr1
; ++ptr1
)
702 for (ptr2
= "0123456789abcdef"; *ptr2
!= '\0'; ++ptr2
)
706 /* Try to open master */
707 pty_master
= open (pty_name
, O_RDWR
);
708 if (pty_master
== -1)
710 if (errno
== ENOENT
) /* Different from EIO */
711 return -1; /* Out of pty devices */
712 continue; /* Try next pty device */
714 pty_name
[5] = 't'; /* Change "pty" to "tty" */
715 if (access (pty_name
, 6) != 0)
724 return -1; /* Ran out of pty devices */
727 /* --------------------------------------------------------------------------------------------- */
728 /** BSD version of pty_open_slave */
731 pty_open_slave (const char *pty_name
)
734 struct group
*group_info
= getgrnam ("tty");
736 if (group_info
!= NULL
)
738 /* The following two calls will only succeed if we are root */
739 /* [Commented out while permissions problem is investigated] */
740 /* chown (pty_name, getuid (), group_info->gr_gid); FIXME */
741 /* chmod (pty_name, S_IRUSR | S_IWUSR | S_IWGRP); FIXME */
743 pty_slave
= open (pty_name
, O_RDWR
);
745 fprintf (stderr
, "open (pty_name, O_RDWR): %s\r\n", pty_name
);
746 fcntl (pty_slave
, F_SETFD
, FD_CLOEXEC
);
749 #endif /* !HAVE_GRANTPT */
750 /* --------------------------------------------------------------------------------------------- */
751 /*** public functions ****************************************************************************/
752 /* --------------------------------------------------------------------------------------------- */
754 /* --------------------------------------------------------------------------------------------- */
756 * Fork the subshell, and set up many, many things.
758 * Possibly modifies the global variables:
759 * subshell_type, subshell_alive, subshell_stopped, subshell_pid
760 * use_subshell - Is set to FALSE if we can't run the subshell
761 * quit - Can be set to SUBSHELL_EXIT by the SIGCHLD handler
767 /* This must be remembered across calls to init_subshell() */
768 static char pty_name
[BUF_SMALL
];
769 char precmd
[BUF_SMALL
];
771 switch (check_sid ())
774 use_subshell
= FALSE
;
777 use_subshell
= FALSE
;
778 midnight_shutdown
= 1;
782 /* Take the current (hopefully pristine) tty mode and make */
783 /* a raw mode based on it now, before we do anything else with it */
786 if (subshell_pty
== 0)
787 { /* First time through */
788 /* Find out what type of shell we have */
790 if (strstr (shell
, "/zsh") || getenv ("ZSH_VERSION"))
792 else if (strstr (shell
, "/tcsh"))
793 subshell_type
= TCSH
;
794 else if (strstr (shell
, "/csh"))
795 subshell_type
= TCSH
;
796 else if (strstr (shell
, "/bash") || getenv ("BASH"))
797 subshell_type
= BASH
;
798 else if (strstr (shell
, "/fish"))
799 subshell_type
= FISH
;
802 use_subshell
= FALSE
;
806 /* Open a pty for talking to the subshell */
808 /* FIXME: We may need to open a fresh pty each time on SVR4 */
810 subshell_pty
= pty_open_master (pty_name
);
811 if (subshell_pty
== -1)
813 fprintf (stderr
, "Cannot open master side of pty: %s\r\n", unix_error_string (errno
));
814 use_subshell
= FALSE
;
817 subshell_pty_slave
= pty_open_slave (pty_name
);
818 if (subshell_pty_slave
== -1)
820 fprintf (stderr
, "Cannot open slave side of pty %s: %s\r\n",
821 pty_name
, unix_error_string (errno
));
822 use_subshell
= FALSE
;
826 /* Create a pipe for receiving the subshell's CWD */
828 if (subshell_type
== TCSH
)
830 g_snprintf (tcsh_fifo
, sizeof (tcsh_fifo
), "%s/mc.pipe.%d",
831 mc_tmpdir (), (int) getpid ());
832 if (mkfifo (tcsh_fifo
, 0600) == -1)
834 fprintf (stderr
, "mkfifo(%s) failed: %s\r\n", tcsh_fifo
, unix_error_string (errno
));
835 use_subshell
= FALSE
;
839 /* Opening the FIFO as O_RDONLY or O_WRONLY causes deadlock */
841 if ((subshell_pipe
[READ
] = open (tcsh_fifo
, O_RDWR
)) == -1
842 || (subshell_pipe
[WRITE
] = open (tcsh_fifo
, O_RDWR
)) == -1)
844 fprintf (stderr
, _("Cannot open named pipe %s\n"), tcsh_fifo
);
845 perror (__FILE__
": open");
846 use_subshell
= FALSE
;
850 else /* subshell_type is BASH or ZSH */ if (pipe (subshell_pipe
))
852 perror (__FILE__
": couldn't create pipe");
853 use_subshell
= FALSE
;
858 /* Fork the subshell */
860 subshell_alive
= TRUE
;
861 subshell_stopped
= FALSE
;
862 subshell_pid
= fork ();
864 if (subshell_pid
== -1)
866 fprintf (stderr
, "Cannot spawn the subshell process: %s\r\n", unix_error_string (errno
));
867 /* We exit here because, if the process table is full, the */
868 /* other method of running user commands won't work either */
872 if (subshell_pid
== 0)
874 /* We are in the child process */
875 init_subshell_child (pty_name
);
878 /* Set up `precmd' or equivalent for reading the subshell's CWD */
880 switch (subshell_type
)
883 g_snprintf (precmd
, sizeof (precmd
),
884 " PROMPT_COMMAND='pwd>&%d;kill -STOP $$'\n", subshell_pipe
[WRITE
]);
888 g_snprintf (precmd
, sizeof (precmd
),
889 " precmd(){ pwd>&%d;kill -STOP $$ }\n", subshell_pipe
[WRITE
]);
893 g_snprintf (precmd
, sizeof (precmd
),
894 "set echo_style=both;"
895 "alias precmd 'echo $cwd:q >>%s;kill -STOP $$'\n", tcsh_fifo
);
898 g_snprintf (precmd
, sizeof (precmd
),
899 "function fish_prompt ; pwd>&%d;kill -STOP %%self; end\n",
900 subshell_pipe
[WRITE
]);
904 write_all (subshell_pty
, precmd
, strlen (precmd
));
906 /* Wait until the subshell has started up and processed the command */
908 subshell_state
= RUNNING_COMMAND
;
909 tty_enable_interrupt_key ();
910 if (!feed_subshell (QUIETLY
, TRUE
))
912 use_subshell
= FALSE
;
914 tty_disable_interrupt_key ();
916 use_subshell
= FALSE
; /* Subshell died instantly, so don't use it */
919 /* --------------------------------------------------------------------------------------------- */
922 invoke_subshell (const char *command
, int how
, char **new_dir
)
926 /* Make the MC terminal transparent */
927 tcsetattr (STDOUT_FILENO
, TCSANOW
, &raw_mode
);
929 /* Make the subshell change to MC's working directory */
931 do_subshell_chdir (current_panel
->cwd
, TRUE
, TRUE
);
933 if (command
== NULL
) /* The user has done "C-o" from MC */
935 if (subshell_state
== INACTIVE
)
937 subshell_state
= ACTIVE
;
938 /* FIXME: possibly take out this hack; the user can
939 re-play it by hitting C-hyphen a few times! */
941 write_all (subshell_pty
, " \b", 2); /* Hack to make prompt reappear */
944 else /* MC has passed us a user command */
947 write_all (subshell_pty
, " ", 1);
948 /* FIXME: if command is long (>8KB ?) we go comma */
949 write_all (subshell_pty
, command
, strlen (command
));
950 write_all (subshell_pty
, "\n", 1);
951 subshell_state
= RUNNING_COMMAND
;
952 subshell_ready
= FALSE
;
955 feed_subshell (how
, FALSE
);
957 pcwd
= vfs_translate_path_n (current_panel
->cwd
);
958 if (new_dir
&& subshell_alive
&& strcmp (subshell_cwd
, pcwd
))
959 *new_dir
= subshell_cwd
; /* Make MC change to the subshell's CWD */
962 /* Restart the subshell if it has died by SIGHUP, SIGQUIT, etc. */
963 while (!subshell_alive
&& quit
== 0 && use_subshell
)
972 /* --------------------------------------------------------------------------------------------- */
975 read_subshell_prompt (void)
977 static int prompt_size
= INITIAL_PROMPT_SIZE
;
978 int bytes
= 0, i
, rc
= 0;
979 struct timeval timeleft
= { 0, 0 };
983 FD_SET (subshell_pty
, &tmp
);
985 if (subshell_prompt
== NULL
)
986 { /* First time through */
987 subshell_prompt
= g_malloc (prompt_size
);
988 *subshell_prompt
= '\0';
992 while (subshell_alive
&& (rc
= select (subshell_pty
+ 1, &tmp
, NULL
, NULL
, &timeleft
)))
994 /* Check for `select' errors */
1001 fprintf (stderr
, "select (FD_SETSIZE, &tmp...): %s\r\n", unix_error_string (errno
));
1002 exit (EXIT_FAILURE
);
1006 bytes
= read (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')
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)
1032 /* --------------------------------------------------------------------------------------------- */
1035 do_update_prompt (void)
1037 if (update_subshell_prompt
)
1039 printf ("\r\n%s", subshell_prompt
);
1041 update_subshell_prompt
= FALSE
;
1045 /* --------------------------------------------------------------------------------------------- */
1047 /** Resize given terminal using TIOCSWINSZ, return ioctl() result */
1051 #if defined TIOCSWINSZ
1052 struct winsize tty_size
;
1054 tty_size
.ws_row
= LINES
;
1055 tty_size
.ws_col
= COLS
;
1056 tty_size
.ws_xpixel
= tty_size
.ws_ypixel
= 0;
1058 return ioctl (fd
, TIOCSWINSZ
, &tty_size
);
1064 /* --------------------------------------------------------------------------------------------- */
1065 /** Resize subshell_pty */
1068 resize_subshell (void)
1070 if (use_subshell
== 0)
1073 resize_tty (subshell_pty
);
1076 /* --------------------------------------------------------------------------------------------- */
1079 exit_subshell (void)
1081 int subshell_quit
= TRUE
;
1083 if (subshell_state
!= INACTIVE
&& subshell_alive
)
1085 !query_dialog (_("Warning"),
1086 _("The shell is still active. Quit anyway?"),
1087 D_NORMAL
, 2, _("&Yes"), _("&No"));
1091 if (subshell_type
== TCSH
)
1093 if (unlink (tcsh_fifo
) == -1)
1094 fprintf (stderr
, "Cannot remove named pipe %s: %s\r\n",
1095 tcsh_fifo
, unix_error_string (errno
));
1098 g_free (subshell_prompt
);
1099 subshell_prompt
= NULL
;
1100 pty_buffer
[0] = '\0';
1103 return subshell_quit
;
1107 /* --------------------------------------------------------------------------------------------- */
1109 * Carefully quote directory name to allow entering any directory safely,
1110 * no matter what weird characters it may contain in its name.
1111 * NOTE: Treat directory name an untrusted data, don't allow it to cause
1112 * executing any commands in the shell. Escape all control characters.
1113 * Use following technique:
1115 * printf(1) with format string containing a single conversion specifier,
1116 * "b", and an argument which contains a copy of the string passed to
1117 * subshell_name_quote() with all characters, except digits and letters,
1118 * replaced by the backslash-escape sequence \0nnn, where "nnn" is the
1119 * numeric value of the character converted to octal number.
1121 * cd "`printf "%b" 'ABC\0nnnDEF\0nnnXYZ'`"
1126 subshell_name_quote (const char *s
)
1130 const char *quote_cmd_start
, *quote_cmd_end
;
1133 if (subshell_type
== FISH
)
1135 quote_cmd_start
= "(printf \"%b\" '";
1136 quote_cmd_end
= "')";
1140 quote_cmd_start
= "\"`printf \"%b\" '";
1141 quote_cmd_end
= "'`\"";
1144 /* Factor 5 because we need \, 0 and 3 other digits per character. */
1145 d
= ret
= g_try_malloc (1 + (5 * strlen (s
)) + (strlen (quote_cmd_start
))
1146 + (strlen (quote_cmd_end
)));
1150 /* Prevent interpreting leading `-' as a switch for `cd' */
1157 /* Copy the beginning of the command to the buffer */
1158 strcpy (d
, quote_cmd_start
);
1159 d
+= strlen (quote_cmd_start
);
1162 * Print every character except digits and letters as a backslash-escape
1163 * sequence of the form \0nnn, where "nnn" is the numeric value of the
1164 * character converted to octal number.
1167 for (; su
[0] != '\0';)
1169 n
= str_cget_next_char_safe (su
);
1170 if (str_isalnum (su
))
1172 memcpy (d
, su
, n
- su
);
1177 for (c
= 0; c
< n
- su
; c
++)
1179 sprintf (d
, "\\0%03o", (unsigned char) su
[c
]);
1186 strcpy (d
, quote_cmd_end
);
1192 /* --------------------------------------------------------------------------------------------- */
1194 /** If it actually changed the directory it returns true */
1196 do_subshell_chdir (const char *directory
, gboolean update_prompt
, gboolean reset_prompt
)
1202 pcwd
= vfs_translate_path_n (current_panel
->cwd
);
1204 if (!(subshell_state
== INACTIVE
&& strcmp (subshell_cwd
, pcwd
) != 0))
1206 /* We have to repaint the subshell prompt if we read it from
1207 * the main program. Please note that in the code after this
1208 * if, the cd command that is sent will make the subshell
1209 * repaint the prompt, so we don't have to paint it. */
1211 do_update_prompt ();
1216 /* The initial space keeps this out of the command history (in bash
1217 because we set "HISTCONTROL=ignorespace") */
1218 write_all (subshell_pty
, " cd ", 4);
1221 translate
= vfs_translate_path_n (directory
);
1224 temp
= subshell_name_quote (translate
);
1227 write_all (subshell_pty
, temp
, strlen (temp
));
1232 /* Should not happen unless the directory name is so long
1233 that we don't have memory to quote it. */
1234 write_all (subshell_pty
, ".", 1);
1240 write_all (subshell_pty
, ".", 1);
1245 write_all (subshell_pty
, "/", 1);
1247 write_all (subshell_pty
, "\n", 1);
1249 subshell_state
= RUNNING_COMMAND
;
1250 feed_subshell (QUIETLY
, FALSE
);
1254 int bPathNotEq
= strcmp (subshell_cwd
, pcwd
);
1256 if (bPathNotEq
&& subshell_type
== TCSH
)
1258 char rp_subshell_cwd
[PATH_MAX
];
1259 char rp_current_panel_cwd
[PATH_MAX
];
1261 char *p_subshell_cwd
= mc_realpath (subshell_cwd
, rp_subshell_cwd
);
1262 char *p_current_panel_cwd
= mc_realpath (pcwd
, rp_current_panel_cwd
);
1264 if (p_subshell_cwd
== NULL
)
1265 p_subshell_cwd
= subshell_cwd
;
1266 if (p_current_panel_cwd
== NULL
)
1267 p_current_panel_cwd
= pcwd
;
1268 bPathNotEq
= strcmp (p_subshell_cwd
, p_current_panel_cwd
);
1271 if (bPathNotEq
&& strcmp (pcwd
, "."))
1273 char *cwd
= strip_password (g_strdup (pcwd
), 1);
1274 fprintf (stderr
, _("Warning: Cannot change to %s.\n"), cwd
);
1281 update_subshell_prompt
= FALSE
;
1284 /* Make sure that MC never stores the CWD in a silly format */
1285 /* like /usr////lib/../bin, or the strcmp() above will fail */
1288 /* --------------------------------------------------------------------------------------------- */
1291 subshell_get_console_attributes (void)
1293 /* Get our current terminal modes */
1295 if (tcgetattr (STDOUT_FILENO
, &shell_mode
))
1297 fprintf (stderr
, "Cannot get terminal settings: %s\r\n", unix_error_string (errno
));
1298 use_subshell
= FALSE
;
1303 /* --------------------------------------------------------------------------------------------- */
1305 * Figure out whether the subshell has stopped, exited or been killed
1306 * Possibly modifies: `subshell_alive', `subshell_stopped' and `quit' */
1309 sigchld_handler (int sig
)
1316 pid
= waitpid (subshell_pid
, &status
, WUNTRACED
| WNOHANG
);
1318 if (pid
== subshell_pid
)
1320 /* Figure out what has happened to the subshell */
1322 if (WIFSTOPPED (status
))
1324 if (WSTOPSIG (status
) == SIGSTOP
)
1326 /* The subshell has received a SIGSTOP signal */
1327 subshell_stopped
= TRUE
;
1331 /* The user has suspended the subshell. Revive it */
1332 kill (subshell_pid
, SIGCONT
);
1337 /* The subshell has either exited normally or been killed */
1338 subshell_alive
= FALSE
;
1339 delete_select_channel (subshell_pty
);
1340 if (WIFEXITED (status
) && WEXITSTATUS (status
) != FORK_FAILURE
)
1341 quit
|= SUBSHELL_EXIT
; /* Exited normally */
1345 pid
= waitpid (cons_saver_pid
, &status
, WUNTRACED
| WNOHANG
);
1347 if (pid
== cons_saver_pid
)
1350 if (WIFSTOPPED (status
))
1351 /* Someone has stopped cons.saver - restart it */
1352 kill (pid
, SIGCONT
);
1355 /* cons.saver has died - disable confole saving */
1356 handle_console (CONSOLE_DONE
);
1361 #endif /* __linux__ */
1363 /* If we got here, some other child exited; ignore it */
1366 /* --------------------------------------------------------------------------------------------- */
1368 #endif /* HAVE_SUBSHELL_SUPPORT */