Ticket #3692: 3692-mc_subshell-V3.patch

lib/shell.c

@@ -33 +33 @@
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <sys/wait.h>
+#include <poll.h>
 
 #include "global.h"
 #include "util.h"
@@ -44 +46 @@
 
 /*** file scope type declarations ****************************************************************/
 
+/* For pipes */
+enum
+{
+    READ = 0,
+    WRITE = 1
+};
+
 /*** file scope variables ************************************************************************/
 
 static char rp_shell[PATH_MAX];
@@ -140 +149 @@
 /* --------------------------------------------------------------------------------------------- */
 
 static void
-mc_shell_recognize_real_path (mc_shell_t * mc_shell)
+mc_shell_append_string (char ** dest, const char * append)
+{
+    char * str;
+
+    if ((dest == NULL) || (append == NULL) || (append[0] == '\0'))
+        return;
+
+    if (*dest == NULL)
+        str = g_strdup (append);
+    else
+        str = g_strdup_printf ("%s%s", *dest, append);
+
+    g_free (*dest);
+    *dest = str;
+}
+
+/* Close fd (we expect a pipe), appending all remaining data in case of input pipe to *dest.
+   If (dest == NULL), we still read all the data in an input pipe to close it properly.
+   Set the fd to -1 to indicate it's closed */
+
+static void
+mc_shell_finalize_fd (int * fd, char ** dest)
 {
-    if (strstr (mc_shell->path, "/zsh") != NULL || strstr (mc_shell->real_path, "/zsh") != NULL
-        || getenv ("ZSH_VERSION") != NULL)
+    struct pollfd fdinfo;
+    int ret;
+    char buff[256];
+    ssize_t size;
+
+    if ((fd == NULL) || (*fd < 0))
+        return;
+
+    fdinfo.fd = *fd;
+    fdinfo.events = POLLIN;
+
+    ret = poll (&fdinfo, 1, 0);
+
+    if ((ret > 0) && ((fdinfo.revents & POLLIN) != 0))
+        fcntl (*fd, F_SETFD, fcntl (*fd, F_GETFD) | O_NONBLOCK);
+
+    while ((ret > 0) && ((fdinfo.revents & POLLIN) != 0))
     {
-        /* Also detects ksh symlinked to zsh */
-        mc_shell->type = SHELL_ZSH;
-        mc_shell->name = "zsh";
+        size = read (*fd, &buff[0], 255);
+
+        if (size > 0)
+        {
+            buff[size] = '\0';
+            mc_shell_append_string (dest, buff);
+        }
+
+        ret = poll (&fdinfo, 1, 0);
     }
-    else if (strstr (mc_shell->path, "/tcsh") != NULL
-             || strstr (mc_shell->real_path, "/tcsh") != NULL)
+
+    if ((fdinfo.revents & POLLNVAL) == 0)
+        close (*fd);
+
+    *fd = -1;
+}
+
+static void *
+mc_shell_waitpid_thread (void * args)
+{
+    int * argsint = (int*)(args), pid = argsint[0], * exit_status = &argsint[1];
+
+    /* wait for child to terminate and get exit_status,
+       or set exit_status to '-1' on waitpid error */
+    if (waitpid (pid, exit_status, 0) == -1)
+        *exit_status = -1;
+
+    /* this signales the parent thread that child terminated */
+    argsint[0] = 0;
+
+    pthread_exit (NULL);
+}
+
+/* Wait for child process to terminate and read/write requested pipes in the process.
+   In case the child is running longer than the timeout value, terminate it with a
+   SIGKILL signal. Timeout is in milliseconds, 0 timeout means no timeout.
+   Returns child exit_status, or '-1' on non positive pid or waitpid () failure */
+static int
+mc_shell_child_wait (int pid, guint timeout, pipes_data_t * pipes)
+{
+    int args[2] = {pid}, i, err;
+    mc_timer_t * start = NULL;
+    pthread_t thread[1];
+
+    if (timeout > 0)
+        start = mc_timer_new ();
+
+    if (pid <= 0)
+        return -1;
+
+    /* launch thread that waits for child process termination and gets the exit status */
+    err = pthread_create(thread, NULL, mc_shell_waitpid_thread, args);
+
+    if (err != 0) /* failed to create thread */
     {
-        /* Also detects csh symlinked to tcsh */
-        mc_shell->type = SHELL_TCSH;
-        mc_shell->name = "tcsh";
+        mc_timer_destroy (start);
+        return -1;
     }
-    else if (strstr (mc_shell->path, "/csh") != NULL
-             || strstr (mc_shell->real_path, "/csh") != NULL)
+
+    if ((pipes != NULL) && (pipes->n > 0))
     {
-        mc_shell->type = SHELL_TCSH;
-        mc_shell->name = "csh";
+        /* we have pipes to poll */
+        int ret, n = pipes->n;
+        struct pollfd * fdinfo = g_new (struct pollfd, n);
+        ssize_t size;
+        char buff[256];
+
+        /* prepare pollfd struct array for poll () and make all pipes non blocking */
+        for (i = 0; i < n; i++)
+        {
+            fdinfo[i].fd = pipes->poll_fds[i];
+            fdinfo[i].events = POLLIN | POLLOUT;
+            fcntl (fdinfo[i].fd, F_SETFD, fcntl (fdinfo[i].fd, F_GETFD) | O_NONBLOCK);
+        }
+
+        ret = poll (fdinfo, n, 0);
+
+        /* while child is running, read/write from/to all requested pipes */
+        while (args[0] > 0)
+        {
+            if (mc_timer_elapsed (start) >= 1000 * timeout)
+            {
+                /* kill spawned child on timeout */
+                kill (pid, SIGKILL);
+                break;
+            } else if (ret > 0)
+                for (i = n - 1; i >= 0; i--)
+                {
+                    if ((fdinfo[i].revents & POLLIN) != 0)
+                    {
+                        /* this is an input pipe, and it has data ready for reading */
+                        size = read (fdinfo[i].fd, buff, 255);
+
+                        if ((pipes->buff[i] != NULL) && (size > 0))
+                        {
+                            buff[size] = '\0';
+                            mc_shell_append_string (pipes->buff[i], buff);
+                        }
+                    } else if ((fdinfo[i].revents & POLLOUT) != 0)
+                    {
+                        /* this is an output pipe, and it is ready for writing */
+
+                        if ((pipes->buff[i] != NULL) && (*(pipes->buff[i]) != NULL))
+                        {
+                            char * source = *(pipes->buff[i]);
+
+                            size = write (fdinfo[i].fd, source, strlen (source));
+
+                            if (size > 0)
+                            {
+                                *(pipes->buff[i]) = g_strdup (&source[size]);
+                                g_free (source);
+                                source = *(pipes->buff[i]);
+                            }
+
+                            if (source[0] == '\0')
+                            {
+                                /* done writing: close the pipe, and remove from fdinfo */
+                                close (fdinfo[i].fd);
+                                fdinfo[i].fd = pipes->poll_fds[i] = -1;
+                            }
+                        } else
+                        {
+                            /* nothing to write: close the pipe, and remove from fdinfo */
+                            close (fdinfo[i].fd);
+                            fdinfo[i].fd = pipes->poll_fds[i] = -1;
+                        }
+                    }
+                }
+
+            ret = poll (fdinfo, n, 0);
+        }
+
+        g_free (fdinfo);
+    } else if (timeout > 0)
+        while (args[0] > 0) /* loop here until child terminates or command timeouts */
+            if (mc_timer_elapsed (start) >= 1000 * timeout)
+            {
+                /* kill spawned child on timeout */
+                kill (pid, SIGKILL);
+                break;
+            }
+
+    /* no need for the timer anymore */
+    mc_timer_destroy (start);
+
+    pthread_join (thread [0], NULL);
+
+    /* read all the remaining data in the pipes and close them */
+    if ((pipes != NULL) && (pipes->n > 0))
+        for (i = 0; i < pipes->n; i++)
+            mc_shell_finalize_fd (&pipes->poll_fds[i], pipes->buff[i]);
+
+    return args[1];
+}
+
+/* ---------------------------------------------------------------------------------------------
+   This function is similar to g_spawn_sync () function with some additional functionality:
+       * add optional timeout to SIGKILL the child after its expiration
+       * optionally feed a string to child's stdin
+       * optionally poll and read/write requested pipes during child execution
+   --------------------------------------------------------------------------------------------- */
+
+static gboolean
+mc_shell_execute (const char * working_directory,
+                        char ** argv,
+                        char ** envp,
+                        GSpawnFlags flags,
+                        GSpawnChildSetupFunc child_setup,
+                        void * user_data,
+                        const char * feed_standard_input,
+                        char ** standard_output,
+                        char ** standard_error,
+                        guint timeout, /* timeout is in milliseconds, 0 timeout means no timeout */
+                        pipes_data_t * pipes,
+                        int * exit_status,
+                        GError ** error)
+{
+    int i, pid, stdin_fd, stdout_fd, stderr_fd, status,
+        * stdin_return = NULL, * stdout_return = NULL, * stderr_return = NULL;
+    char * standard_input = NULL;
+    pipes_data_t pipes_data;
+
+    pipes_data.n = 0;
+
+    if ((pipes != NULL) && (pipes->n > 0))
+    {
+        pipes_data.n = pipes->n;
+
+        /* without this the requested pipes will be closed for the child */
+        flags |= G_SPAWN_LEAVE_DESCRIPTORS_OPEN;
+
+        /* make parent sides of the pipes get closed for the child */
+        for (i = 0; i < pipes->n; i++)
+            fcntl (pipes->poll_fds[i], F_SETFD, fcntl (pipes->poll_fds[i], F_GETFD) | FD_CLOEXEC);
     }
-    else if (strstr (mc_shell->path, "/fish") != NULL
-             || strstr (mc_shell->real_path, "/fish") != NULL)
+
+    /* we'll reap the child ourselves with waitpid () */
+    flags |= G_SPAWN_DO_NOT_REAP_CHILD;
+
+    if (feed_standard_input != NULL)
     {
-        mc_shell->type = SHELL_FISH;
-        mc_shell->name = "fish";
+        stdin_return = &stdin_fd;
+        pipes_data.n++;
     }
-    else if (strstr (mc_shell->path, "/dash") != NULL
-             || strstr (mc_shell->real_path, "/dash") != NULL)
+
+    if (standard_output != NULL)
     {
-        /* Debian ash (also found if symlinked to by ash/sh) */
-        mc_shell->type = SHELL_DASH;
-        mc_shell->name = "dash";
+        stdout_return = &stdout_fd;
+        pipes_data.n++;
     }
-    else if (strstr (mc_shell->real_path, "/busybox") != NULL)
+    else
+        flags |= G_SPAWN_STDOUT_TO_DEV_NULL;
+
+    if (standard_error != NULL)
     {
-        /* If shell is symlinked to busybox, assume it is an ash, even though theoretically
-         * it could also be a hush (a mini shell for non-MMU systems deactivated by default).
-         * For simplicity's sake we assume that busybox always contains an ash, not a hush.
-         * On embedded platforms or on server systems, /bin/sh often points to busybox.
-         * Sometimes even bash is symlinked to busybox (CONFIG_FEATURE_BASH_IS_ASH option),
-         * so we need to check busybox symlinks *before* checking for the name "bash"
-         * in order to avoid that case. */
-        mc_shell->type = SHELL_ASH_BUSYBOX;
-        mc_shell->name = mc_shell->path;
+        stderr_return = &stderr_fd;
+        pipes_data.n++;
     }
     else
-        mc_shell->type = SHELL_NONE;
+        flags |= G_SPAWN_STDERR_TO_DEV_NULL;
+
+    if (!g_spawn_async_with_pipes (working_directory, argv, envp, flags,
+             child_setup, user_data, &pid, stdin_return, stdout_return, stderr_return, error))
+    {
+        g_strfreev (envp);
+        return FALSE;
+    }
+
+    pipes_data.poll_fds = g_new(int, pipes_data.n);
+    pipes_data.buff = g_new(char**, pipes_data.n);
+    pipes_data.n = 0;
+
+    if ((pipes != NULL) && (pipes->n > 0))
+    {
+        pipes_data.n = pipes->n;
+
+        for (i = 0; i < pipes->n; i++)
+        {
+            pipes_data.poll_fds[i] = pipes->poll_fds[i];
+            pipes_data.buff[i] = pipes->buff[i];
+            /* close child sides of pipes for the parent */
+            mc_shell_finalize_fd (&pipes->close_fds[i], NULL);
+        }
+    }
+
+    if (standard_output != NULL)
+    {
+        pipes_data.poll_fds[pipes_data.n] = stdout_fd;
+        pipes_data.buff[pipes_data.n] = standard_output;
+        pipes_data.n++;
+    }
+
+    if (standard_error != NULL)
+    {
+        pipes_data.poll_fds[pipes_data.n] = stderr_fd;
+        pipes_data.buff[pipes_data.n] = standard_error;
+        pipes_data.n++;
+    }
+
+    if (feed_standard_input != NULL)
+    {
+        standard_input = g_strdup (feed_standard_input);
+        pipes_data.poll_fds[pipes_data.n] = stdin_fd;
+        pipes_data.buff[pipes_data.n] = &standard_input;
+        pipes_data.n++;
+    }
+
+    status = mc_shell_child_wait (pid, timeout, &pipes_data);
+
+    if (exit_status != NULL)
+        *exit_status = status;
+
+    if ((pipes != NULL) && (pipes->n > 0))
+    {
+        /* the poll_fds are supposed to be closed now, and pipes_data.poll_fds[i] set to '-1', so let
+           the function caller know they're closed by setting pipes->poll_fds[i] to '-1' too */
+        for (i = 0; i < pipes->n; i++)
+            pipes->poll_fds[i] = pipes_data.poll_fds[i];
+    }
+
+    g_free (standard_input);
+    g_free (pipes_data.poll_fds);
+    g_free (pipes_data.buff);
+
+    return TRUE;
+}
+
+/* ---------------------------------------------------------------------------------------------
+   This function returns TRUE for a shell if it sets a variable with respective name. We unset
+   environmental variable of the same name in the child envp to make sure it's not inherited.
+   We use three different commands for the respective shell syntaxes: bourne, C and fish.
+   We test for exit code and stdout output to check if the command was successful.
+   If we test a shell with a wrong syntax, it returns error code, and function returns FALSE,
+   so in fact we test for syntax first, and only then for shell setting the variable.
+   --------------------------------------------------------------------------------------------- */
+static gboolean
+mc_shell_internal_variable_set (mc_shell_t * mc_shell, const char * name,
+                                const shell_syntax_t shell_syntax)
+{
+    /* define arg1 instead of using "-c" directly when assigning argv to
+       silence [-Wdiscarded-qualifiers] compiler warning */
+    char arg1[] = "-c", * argv[] = {mc_shell->path, arg1, NULL, NULL}, * standard_output = NULL;
+    char ** envp;
+    int exit_status;
+    size_t i, shift, len1, len2;
+    gboolean success;
+
+    /* copy parent's envp and unset the environmental variable in question if set */
+    envp = g_strdupv (environ);
+    len1 = g_strv_length (envp);
+    len2 = strlen (name);
+
+    for (i = shift = 0; i < len1; i++)
+    {
+        if ((strncmp (name, envp [i], len2) == 0) && (envp [i][len2] == '='))
+        {
+            g_free (envp [i]);
+            shift++;
+        } else
+            envp [i - shift] = envp [i];
+    }
+    for (i = len1 - shift; i < len1; i++)
+        envp [i] = NULL;
+
+    /* for proper shells these commands return 0 exit code and print 'name' value to stdout */
+    if (shell_syntax == SHELL_SYNTAX_BOURNE)
+        argv[2] = g_strdup_printf ("if [ -z ${%s+x} ]; then "
+                                       "exit 1;"
+                                   "else "
+                                       "printf '%s';"
+                                   "fi", name, name);
+    else if (shell_syntax == SHELL_SYNTAX_C)
+        argv[2] = g_strdup_printf ("if !( $?%s ) then\n"
+                                       "exit 1\n"
+                                   "else\n"
+                                       "printf '%s'\n"
+                                   "endif", name, name);
+    else /* shell_syntax == SHELL_SYNTAX_FISH */
+        argv[2] = g_strdup_printf ("if set -q %s;"
+                                       "printf '%s';"
+                                   "else;"
+                                       "exit 1;"
+                                   "end", name, name);
+
+
+    success = mc_shell_execute (NULL, argv, envp, 0, NULL, NULL, NULL, &standard_output,
+                                NULL, 100, NULL, &exit_status, NULL) &&
+              g_spawn_check_exit_status (exit_status, NULL) &&
+              (g_strcmp0  (standard_output, name) == 0);
+
+    g_free (argv[2]);
+    g_free (standard_output);
+
+    return success;
 }
 
 /* --------------------------------------------------------------------------------------------- */
 
 static void
-mc_shell_recognize_path (mc_shell_t * mc_shell)
+mc_shell_recognize_from_internal_variable (mc_shell_t * mc_shell)
 {
-    /* If shell is not symlinked to busybox, it is safe to assume it is a real shell */
-    if (strstr (mc_shell->path, "/bash") != NULL || getenv ("BASH") != NULL)
-    {
+    /* These tests recognize bash, zsh, tcsh and fish by testing for
+       variables that only these shells set */
+    if (mc_shell_internal_variable_set (mc_shell, "BASH", SHELL_SYNTAX_BOURNE)) {
         mc_shell->type = SHELL_BASH;
-        mc_shell->name = "bash";
     }
-    else if (strstr (mc_shell->path, "/sh") != NULL || getenv ("SH") != NULL)
+    else if (mc_shell_internal_variable_set (mc_shell, "ZSH_NAME", SHELL_SYNTAX_BOURNE))
+    {
+        mc_shell->type = SHELL_ZSH;
+    }
+    else if (mc_shell_internal_variable_set (mc_shell, "tcsh", SHELL_SYNTAX_C))
     {
-        mc_shell->type = SHELL_SH;
-        mc_shell->name = "sh";
+        mc_shell->type = SHELL_TCSH;
     }
-    else if (strstr (mc_shell->path, "/ash") != NULL || getenv ("ASH") != NULL)
+    else if (mc_shell_internal_variable_set (mc_shell, "fish_greeting", SHELL_SYNTAX_FISH))
     {
-        mc_shell->type = SHELL_ASH_BUSYBOX;
-        mc_shell->name = "ash";
+        mc_shell->type = SHELL_FISH;
     }
     else
         mc_shell->type = SHELL_NONE;
 }
 
+/* ---------------------------------------------------------------------------------------------
+   This function tests whether a shell treats PS1 as prompt string that is being expanded.
+   We test for an old BusyBox ash 4-digit octal codes bug in printf along the way too.
+   mc_shell->type will be set to:
+      SHELL_DASH: Test for PS1 expansion succeeds fully. This can mean dash, or BusyBox ash
+                  with CONFIG_ASH_EXPAND_PRMT enabled, or something other compatible
+      SHELL_ASH_BUSYBOX_LEGACY: PS1 is being expanded, but printf suffers from the 4-digit octal
+                                codes bug, so apply the printf workaround
+      SHELL_NONE: Test failed. Possible reasons: PS1 is not being treated as a prompt string,
+                  PS1 is not being expanded (no CONFIG_ASH_EXPAND_PRMT in BusyBox ash?),
+                  shell doesn't recognize syntax, failed to execute shell, etc.
+   --------------------------------------------------------------------------------------------- */
+static void
+mc_shell_test_prompt_expansion (mc_shell_t * mc_shell)
+{
+    /* define arg1 instead of using "-i" directly when assigning argv to
+       silence [-Wdiscarded-qualifiers] compiler warning */
+    char arg1[] = "-i", * argv[] = {mc_shell->path, arg1, NULL},
+         ** envp, * standard_input;
+    int subshell_pipe[2], exit_status;
+    size_t i, len;
+
+    char * out_buff = NULL, ** out_buff_addr = &out_buff;
+    pipes_data_t pipes;
+
+    if (pipe (subshell_pipe))
+    {
+        /* failed to create pipe */
+        mc_shell->type = SHELL_NONE;
+        return;
+    }
+
+    /* copy parent's envp and override the PS1 env variable to safe non-interactive if set */
+    envp = g_strdupv (environ);
+    len = g_strv_length (envp);
+
+    for (i = 0; i < len; i++)
+    {
+        if (strncmp ("PS1=", envp [i], 4) == 0)
+        {
+            g_free (envp [i]);
+            envp [i] = g_strdup ("PS1=$ ");
+        }
+    }
+
+    /* Check if executing `PS1='$(printf "%b" "\\0057a\\0057\\n" >&subshell_pipe[WRITE])'` command
+    in interactive mode gets PS1 evaluated before the next `exit 0` command, by capturing the pipe
+    output, and comparing it to the expected output for dash / BusyBox ash ("/a/"), and
+    if it doesn't match - to BusyBox pre 1.20 broken printf output ("\005""7a""\005""7") */
+
+    standard_input = g_strdup_printf ("PS1='$(printf \"%%b\" \"\\\\0057a\\\\0057\" >&%d)'\n"
+                                      "exit 0\n", subshell_pipe[WRITE]);
+
+    pipes.buff      = &out_buff_addr;        /* pipes.buff is an array of pointers to strings */
+    pipes.poll_fds  = &subshell_pipe[READ];  /* int array of pipes to poll */
+    pipes.close_fds = &subshell_pipe[WRITE]; /* int array of pipes to close for the parent */
+    pipes.n         = 1;                     /* pipes.n is the number of pipes */
+
+    if (mc_shell_execute (NULL, argv, envp, 0, NULL, NULL, standard_input, NULL,
+                          NULL, 100, &pipes, &exit_status, NULL) &&
+        g_spawn_check_exit_status (exit_status, NULL))
+    {
+        if (g_strcmp0  (out_buff, "/a/") == 0)
+            mc_shell->type = SHELL_DASH;
+        else if (g_strcmp0  (out_buff, "\005""7a""\005""7") == 0)
+            mc_shell->type = SHELL_ASH_BUSYBOX_LEGACY;
+        else
+            mc_shell->type = SHELL_NONE;
+    }
+    else
+        mc_shell->type = SHELL_NONE;
+
+    g_free (out_buff);
+    g_free (standard_input);
+
+    /* if mc_shell_execute () failed */
+    mc_shell_finalize_fd (&subshell_pipe[WRITE], NULL);
+    mc_shell_finalize_fd (&subshell_pipe[READ], NULL);
+}
+
 /* --------------------------------------------------------------------------------------------- */
 /*** public functions ****************************************************************************/
 /* --------------------------------------------------------------------------------------------- */
@@ -232 +669 @@
 
     mc_shell->real_path = mc_realpath (mc_shell->path, rp_shell);
 
-    /* Find out what type of shell we have. Also consider real paths (resolved symlinks)
-     * because e.g. csh might point to tcsh, ash to dash or busybox, sh to anything. */
+    /* Find out what type of shell we have. Use tests for specific variables that
+     * different shells set for most shell types. To recognize dash, or compatible
+     * BusyBox ash, we test whether prompt expansion works. */
 
-    if (mc_shell->real_path != NULL)
-        mc_shell_recognize_real_path (mc_shell);
+    if (mc_shell->real_path != NULL) {
+       mc_shell_recognize_from_internal_variable (mc_shell);
 
-    if (mc_shell->type == SHELL_NONE)
-        mc_shell_recognize_path (mc_shell);
+       if (mc_shell->type == SHELL_NONE)
+           mc_shell_test_prompt_expansion (mc_shell);
 
-    if (mc_shell->type == SHELL_NONE)
-        mc_global.tty.use_subshell = FALSE;
+       if (mc_shell->type == SHELL_NONE)
+           fprintf (stderr, __FILE__ ": failed to recognize shell \"%s\" as supported subshell. "
+                                       "Supported shells are: bash, zsh, tcsh, fish, dash and "
+                                       "BusyBox ash with enabled CONFIG_ASH_EXPAND_PRMT\r\n",
+                                        mc_shell->path);
+   } else {
+       mc_shell->type = SHELL_NONE;
+       fprintf (stderr, __FILE__ ": wrong \"%s\" shell: No such file\r\n", mc_shell->path);
+   }
 
+    mc_global.tty.use_subshell = mc_shell->type != SHELL_NONE;
     mc_global.shell = mc_shell;
 }
 

lib/shell.h

@@ -12 +12 @@
 typedef enum
 {
     SHELL_NONE,
-    SHELL_SH,
     SHELL_BASH,
-    SHELL_ASH_BUSYBOX,          /* BusyBox default shell (ash) */
-    SHELL_DASH,                 /* Debian variant of ash */
+    SHELL_DASH,       /* Debian variant of ash, or BusyBox ash shell with CONFIG_ASH_EXPAND_PRMT */
+    SHELL_ASH_BUSYBOX_LEGACY,   /* Legacy BusyBox ash shell with broken printf */
     SHELL_TCSH,
     SHELL_ZSH,
     SHELL_FISH
 } shell_type_t;
 
+typedef enum
+{
+    SHELL_SYNTAX_BOURNE,
+    SHELL_SYNTAX_C,
+    SHELL_SYNTAX_FISH
+} shell_syntax_t;
+
 /*** structures declarations (and typedefs of structures)*****************************************/
 
 typedef struct
 {
     shell_type_t type;
-    const char *name;
     char *path;
     char *real_path;
 } mc_shell_t;
 
+/* This structure stores information on input/output pipes fds and buffers.
+   Input pipes should have their data appended to *(buff[i]),
+   and output pipes should have *(buff[i]) written to them.
+   On successful writes to output pipes respective *(buff[i]) gets
+   gradually emptied, and when all data is written, the write end of the
+   pipe should be closed */
+typedef struct
+{
+    int * poll_fds;
+    int * close_fds;
+    char *** buff;
+    int n;
+} pipes_data_t;
+
 /*** global variables defined in .c file *********************************************************/
 
 /*** declarations of public functions ************************************************************/
@@ -40 +59 @@
 
 /*** inline functions **************************************************/
 
+static inline const char* shell_type_string (shell_type_t shell_type)
+{
+    switch (shell_type)
+    {
+    case SHELL_NONE:
+        return "NONE";
+    case SHELL_BASH:
+        return "BASH";
+    case SHELL_DASH:
+        return "DASH";
+    case SHELL_ASH_BUSYBOX_LEGACY:
+        return "ASH_BUSYBOX_LEGACY";
+    case SHELL_TCSH:
+        return "TCSH";
+    case SHELL_ZSH:
+        return "ZSH";
+    case SHELL_FISH:
+        return "FISH";
+    default:
+        return "UNKNOWN";
+    }
+}
+
 #endif /* MC_SHELL_H */

src/subshell/common.c

@@ -249 +249 @@
     tty_resize (subshell_pty_slave);
 
     /* Set up the subshell's environment and init file name */
-
-    /* It simplifies things to change to our home directory here, */
-    /* and the user's startup file may do a 'cd' command anyway   */
     {
         int ret;
 
-        ret = chdir (mc_config_get_home_dir ());        /* FIXME? What about when we re-run the subshell? */
         (void) ret;
     }
 
@@ -279 +275 @@
         if (!exist_file (init_file))
         {
             g_free (init_file);
-            init_file = g_strdup (".bashrc");
+            init_file = g_build_filename (g_getenv ("HOME"), ".bashrc", (char *) NULL);
         }
 
         /* Make MC's special commands not show up in bash's history and also suppress
@@ -301 +297 @@
 
         break;
 
-    case SHELL_ASH_BUSYBOX:
+    case SHELL_ASH_BUSYBOX_LEGACY:
     case SHELL_DASH:
         /* Do we have a custom init file ~/.local/share/mc/ashrc? */
         init_file = mc_config_get_full_path ("ashrc");
@@ -310 +306 @@
         if (!exist_file (init_file))
         {
             g_free (init_file);
-            init_file = g_strdup (".profile");
+            init_file = g_build_filename (g_getenv ("HOME"), ".profile", (char *) NULL);
         }
 
         /* Put init file to ENV variable used by ash */
@@ -327 +323 @@
         break;
 
     default:
-        fprintf (stderr, __FILE__ ": unimplemented subshell type %u\r\n", mc_global.shell->type);
+        fprintf (stderr, __FILE__ ": unimplemented subshell type %s\r\n", shell_type_string (mc_global.shell->type));
         my_exit (FORK_FAILURE);
     }
 
@@ -355 +351 @@
     switch (mc_global.shell->type)
     {
     case SHELL_BASH:
-        execl (mc_global.shell->path, "bash", "-rcfile", init_file, (char *) NULL);
+        execl (mc_global.shell->path, mc_global.shell->path, "-rcfile", init_file, (char *) NULL);
         break;
 
     case SHELL_ZSH:
         /* Use -g to exclude cmds beginning with space from history
          * and -Z to use the line editor on non-interactive term */
+        /* zsh is sensitive about arg0 value to the point of failing
+           to initialize subshell when arg0 basename isn't "zsh" */
         execl (mc_global.shell->path, "zsh", "-Z", "-g", (char *) NULL);
 
         break;
 
-    case SHELL_ASH_BUSYBOX:
+    case SHELL_ASH_BUSYBOX_LEGACY:
     case SHELL_DASH:
     case SHELL_TCSH:
     case SHELL_FISH:
@@ -801 +799 @@
                     "PS1='\\u@\\h:\\w\\$ '\n", subshell_pipe[WRITE]);
         break;
 
-    case SHELL_ASH_BUSYBOX:
-        /* BusyBox ash needs a somewhat complicated precmd emulation via PS1, and it is vital
-         * that BB be built with active CONFIG_ASH_EXPAND_PRMT, but this is the default anyway.
-         *
-         * A: This leads to a stopped subshell (=frozen mc) if user calls "ash" command
-         *    "PS1='$(pwd>&%d; kill -STOP $$)\\u@\\h:\\w\\$ '\n",
-         *
-         * B: This leads to "sh: precmd: not found" in sub-subshell if user calls "ash" command
-         *    "precmd() { pwd>&%d; kill -STOP $$; }; "
-         *    "PS1='$(precmd)\\u@\\h:\\w\\$ '\n",
-         *
-         * C: This works if user calls "ash" command because in sub-subshell
-         *    PRECMD is unfedined, thus evaluated to empty string - no damage done.
-         *    Attention: BusyBox must be built with FEATURE_EDITING_FANCY_PROMPT to
-         *    permit \u, \w, \h, \$ escape sequences. Unfortunately this cannot be guaranteed,
-         *    especially on embedded systems where people try to save space, so let's use
-         *    the dash version below. It should work on virtually all systems.
-         *    "precmd() { pwd>&%d; kill -STOP $$; }; "
-         *    "PRECMD=precmd; "
-         *    "PS1='$(eval $PRECMD)\\u@\\h:\\w\\$ '\n",
-         */
+    case SHELL_ASH_BUSYBOX_LEGACY:
     case SHELL_DASH:
-        /* Debian ash needs a precmd emulation via PS1, similar to BusyBox ash,
-         * but does not support escape sequences for user, host and cwd in prompt.
+        /* Debian ash needs a precmd emulation via PS1.
          * Attention! Make sure that the buffer for precmd is big enough.
          *
-         * We want to have a fancy dynamic prompt with user@host:cwd just like in the BusyBox
-         * examples above, but because replacing the home directory part of the path by "~" is
+         * We want to have a fancy dynamic prompt with user@host:cwd,
+         * but because replacing the home directory part of the path by "~" is
          * complicated, it bloats the precmd to a size > BUF_SMALL (128).
          *
          * The following example is a little less fancy (home directory not replaced)
@@ -924 +901 @@
         quote_cmd_start = "(printf \"%b\" '";
         quote_cmd_end = "')";
     }
-    /* TODO: When BusyBox printf is fixed, get rid of this "else if", see
-       http://lists.busybox.net/pipermail/busybox/2012-March/077460.html */
-    /* else if (subshell_type == ASH_BUSYBOX)
+    /* see http://lists.busybox.net/pipermail/busybox/2012-March/077460.html */
+    else if (mc_global.shell->type == SHELL_ASH_BUSYBOX_LEGACY)
        {
        quote_cmd_start = "\"`echo -en '";
        quote_cmd_end = "'`\"";
-       } */
+       }
     else
     {
         quote_cmd_start = "\"`printf \"%b\" '";
@@ -1059 +1035 @@
                 return;
             }
         }
-        else if (pipe (subshell_pipe))  /* subshell_type is BASH, ASH_BUSYBOX, DASH or ZSH */
+        else if (pipe (subshell_pipe))  /* subshell_type is BASH, ASH_BUSYBOX_LEGACY, DASH or ZSH */
         {
             perror (__FILE__ ": couldn't create pipe");
             mc_global.tty.use_subshell = FALSE;
@@ -1102 +1078 @@
     tty_disable_interrupt_key ();
     if (!subshell_alive)
         mc_global.tty.use_subshell = FALSE;     /* Subshell died instantly, so don't use it */
+    if (!mc_global.tty.use_subshell)
+        fprintf (stderr, __FILE__ ": failed to initialize \"%s\" shell of type %s\r\n", mc_global.shell->path, shell_type_string (mc_global.shell->type));
 }
 
 /* --------------------------------------------------------------------------------------------- */