Ticket #4114: persistent_subshell_command_buffer.patch

src/execute.c

@@ -551 +551 @@
     {
         if (mc_global.mc_run_mode == MC_RUN_FULL)
         {
-            do_load_prompt ();
             if (new_dir_vpath != NULL)
                 do_possible_cd (new_dir_vpath);
         }

src/subshell/common.c

@@ -105 +105 @@
 #include "lib/util.h"
 #include "lib/widget.h"
 
+#include "src/filemanager/layout.h"        /* setup_cmdline() */
+#include "src/filemanager/command.h"        /* cmdline */
+
 #include "subshell.h"
 #include "internal.h"
 
@@ -169 +172 @@
 /* To pass CWD info from the subshell to MC */
 static int subshell_pipe[2];
 
+/* To pass command buffer info from the subshell to MC */
+static int command_buffer_pipe[2];
+
 /* The subshell's process ID */
 static pid_t subshell_pid = 1;
 
@@ -178 +184 @@
 /* Flag to indicate whether the subshell is ready for next command */
 static int subshell_ready;
 
+/* Flag to indicate if the contents of the subshell command line need to be cleared before */
+/* executing a command. This should only end up set to true if there is some sort of error.*/
+/* This allows us to recover gracefully from an error.*/
+static int subshell_should_clear_command_line;
+
+/* This is the local variable where the subshell prompt is stored while we are working on it. */
+static GString *subshell_prompt_temp_buffer = NULL;
+
 /* The following two flags can be changed by the SIGCHLD handler. This is */
 /* OK, because the 'int' type is updated atomically on all known machines */
 static volatile int subshell_alive, subshell_stopped;
@@ -362 +376 @@
     dup2 (subshell_pty_slave, STDERR_FILENO);
 
     close (subshell_pipe[READ]);
+    if (mc_global.shell->type == SHELL_BASH || mc_global.shell->type == SHELL_ZSH || mc_global.shell->type == SHELL_FISH)
+        close (command_buffer_pipe[READ]);
     close (subshell_pty_slave); /* These may be FD_CLOEXEC, but just in case... */
     /* Close master side of pty.  This is important; apart from */
     /* freeing up the descriptor for use in the subshell, it also       */
@@ -469 +485 @@
 }
 
 /* --------------------------------------------------------------------------------------------- */
+
+static int
+flush_subshell (int max_wait_length)
+{
+    int rc = 0;
+    ssize_t bytes = 0;
+    struct timeval timeleft = { 0, 0 };
+    int return_value = 0;
+    fd_set tmp;
+
+    timeleft.tv_sec = max_wait_length;
+    FD_ZERO (&tmp);
+    FD_SET (mc_global.tty.subshell_pty, &tmp);
+
+    while (subshell_alive
+           && (rc = select (mc_global.tty.subshell_pty + 1, &tmp, NULL, NULL, &timeleft)) != 0)
+    {
+        /* Check for 'select' errors */
+        if (rc == -1)
+        {
+            if (errno == EINTR)
+            {
+                if (tty_got_winch ())
+                    tty_change_screen_size ();
+
+                continue;
+            }
+
+            fprintf (stderr, "select (FD_SETSIZE, &tmp...): %s\r\n", unix_error_string (errno));
+            exit (EXIT_FAILURE);
+        }
+        return_value = 1;
+        timeleft.tv_sec = 0;
+        timeleft.tv_usec = 0;
+
+        bytes = read (mc_global.tty.subshell_pty, pty_buffer, sizeof (pty_buffer));
+        write_all (STDOUT_FILENO, pty_buffer, bytes);
+    }
+    return return_value;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/* Get the contents of the current subshell command line buffer, and */
+/* transfer the contents to the panel command prompt. */
+
+static gboolean
+read_command_line_buffer(void)
+{
+    fd_set read_set;
+    int j;
+    int bytes;
+    char subshell_command_buffer[BUF_LARGE];
+    struct timeval subshell_prompt_timer = { 0, 0 };
+    int command_buffer_length;
+    int cursor_position;
+    int maxfdp;
+
+    if (mc_global.shell->type == SHELL_BASH || mc_global.shell->type == SHELL_ZSH || mc_global.shell->type == SHELL_FISH)
+    {
+        FD_ZERO (&read_set);
+        FD_SET (command_buffer_pipe[READ], &read_set);
+        maxfdp = command_buffer_pipe[READ];
+        /* First, flush the command buffer pipe. This pipe shouldn't be written
+           to under normal circumstances, but if it somehow does get written
+           to, we need to make sure to discard whatever data is there before
+           we try to use it. */
+        while (select (maxfdp + 1, &read_set, NULL, NULL, &subshell_prompt_timer) != 0)
+        {
+            bytes = read (command_buffer_pipe[READ], subshell_command_buffer, sizeof(subshell_command_buffer));
+        }
+
+        subshell_prompt_timer.tv_sec = 1;
+        /* get contents of command line buffer */
+        write_all (mc_global.tty.subshell_pty, "\033[98~", 5);
+        FD_ZERO (&read_set);
+        FD_SET (command_buffer_pipe[READ], &read_set);
+        maxfdp = command_buffer_pipe[READ];
+        if (select (maxfdp + 1, &read_set, NULL, NULL, &subshell_prompt_timer) != 1)
+            return 1;
+        bytes = read (command_buffer_pipe[READ], subshell_command_buffer, sizeof(subshell_command_buffer));
+        if (bytes == sizeof(subshell_command_buffer))
+            return 1;
+        subshell_command_buffer[bytes - 1] = 0;
+
+        /* Erase all non-text characters in the command buffer, such as tab, or newline, as this could cause problems. */
+        for(j = 0;j < bytes - 1;j++)
+        {
+            if (!(subshell_command_buffer[j] >= 32 && subshell_command_buffer[j] <= 126))
+                subshell_command_buffer[j] = ' ';
+        }
+        input_assign_text (cmdline, subshell_command_buffer);
+        command_buffer_length = bytes - 1;
+
+        /* get cursor position */
+        write_all (mc_global.tty.subshell_pty, "\033[99~", 5);
+        FD_ZERO (&read_set);
+        FD_SET (command_buffer_pipe[READ], &read_set);
+        maxfdp = command_buffer_pipe[READ];
+        if (select (maxfdp + 1, &read_set, NULL, NULL, &subshell_prompt_timer) != 1)
+            return 1;
+        bytes = read (command_buffer_pipe[READ], subshell_command_buffer, sizeof(subshell_command_buffer));
+        subshell_command_buffer[bytes - 1] = 0;
+        cursor_position = atoi(subshell_command_buffer);
+        cmdline->point = cursor_position;
+        flush_subshell(0);    /* We need to send any remaining data to STDOUT before we finish. */
+
+        /* Now we erase the current contents of the command line buffer */
+        if (mc_global.shell->type != SHELL_ZSH)    /* In zsh, we can just press c-u to clear the line, without needing to go to the end of the line first first. In all other shells, we must go to the end of the line first. */
+        {
+            if (cursor_position != command_buffer_length)  /* If we are not at the end of the line, we go to the end. */
+            {
+                write_all (mc_global.tty.subshell_pty, "\005", 1);
+                if (flush_subshell(1) != 1)
+                    return 1;
+            }
+        }
+        if (command_buffer_length > 0)    /* Now we clear the line. */
+        {
+            write_all (mc_global.tty.subshell_pty, "\025", 1);
+            if (flush_subshell(1) != 1)
+                return 1;
+        }
+    }
+    return 0;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static void
+clear_subshell_prompt_string (void)
+{
+    if(subshell_prompt_temp_buffer != NULL)
+        g_string_set_size (subshell_prompt_temp_buffer, 0);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static gboolean
+parse_subshell_prompt_string (const char *buffer, int bytes)
+{
+    int rc = 0;
+    int i;
+
+    /* First time through */
+    if (subshell_prompt == NULL)
+    {
+        subshell_prompt = g_string_sized_new (INITIAL_PROMPT_SIZE);
+    }
+    if (subshell_prompt_temp_buffer == NULL)
+    {
+        subshell_prompt_temp_buffer = g_string_sized_new (INITIAL_PROMPT_SIZE);
+    }
+
+    /* Extract the prompt from the shell output */
+    for (i = 0; i < bytes; i++)
+        if (buffer[i] == '\n' || buffer[i] == '\r')
+        {
+            g_string_set_size (subshell_prompt_temp_buffer, 0);
+        }
+        else if (buffer[i] != '\0')
+            g_string_append_c (subshell_prompt_temp_buffer, buffer[i]);
+
+    return (rc != 0 || bytes != 0);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static void
+set_prompt_string (void)
+{
+    if (subshell_prompt_temp_buffer->len != 0)
+        g_string_assign (subshell_prompt, subshell_prompt_temp_buffer->str);
+
+    setup_cmdline();
+}
+
+/* --------------------------------------------------------------------------------------------- */
 /** Feed the subshell our keyboard input until it says it's finished */
 
 static gboolean
@@ -477 +670 @@
     fd_set read_set;            /* For 'select' */
     int bytes;                  /* For the return value from 'read' */
     int i;                      /* Loop counter */
+    int should_read_new_prompt = FALSE;
 
     struct timeval wtime;       /* Maximum time we wait for the subshell */
     struct timeval *wptr;
 
+    subshell_should_clear_command_line = FALSE;
+
     /* we wait up to 10 seconds if fail_on_error, forever otherwise */
     wtime.tv_sec = 10;
     wtime.tv_usec = 0;
@@ -549 +745 @@
 
             if (how == VISIBLY)
                 write_all (STDOUT_FILENO, pty_buffer, bytes);
+            if (should_read_new_prompt)
+            {
+                parse_subshell_prompt_string(pty_buffer, bytes);
+            }
+
         }
 
         else if (FD_ISSET (subshell_pipe[READ], &read_set))
@@ -573 +774 @@
                 subshell_state = INACTIVE;
                 return TRUE;
             }
+            should_read_new_prompt = TRUE;
+            clear_subshell_prompt_string();
         }
 
         else if (FD_ISSET (STDIN_FILENO, &read_set))
             /* Read from stdin, write to the subshell */
         {
+            should_read_new_prompt = FALSE;
             bytes = read (STDIN_FILENO, pty_buffer, sizeof (pty_buffer));
             if (bytes <= 0)
             {
@@ -592 +796 @@
                 {
                     write_all (mc_global.tty.subshell_pty, pty_buffer, i);
                     if (subshell_ready)
+                    {
                         subshell_state = INACTIVE;
+                        set_prompt_string ();
+                        if (subshell_ready == TRUE && read_command_line_buffer() != 0)
+                        {
+                            /* If we got here, some unforseen error must have occurred. */
+                            flush_subshell(0);
+                            input_assign_text (cmdline, "");
+                            subshell_should_clear_command_line = TRUE;
+                            return TRUE;
+                        }
+                    }
                     return TRUE;
                 }
 
             write_all (mc_global.tty.subshell_pty, pty_buffer, bytes);
 
             if (pty_buffer[bytes - 1] == '\n' || pty_buffer[bytes - 1] == '\r')
+            {
+                /* We should only clear the command line if we are using a shell that supports persistent command buffer,
+                   otherwise we get awkward results. */
+                if (mc_global.shell->type == SHELL_BASH || mc_global.shell->type == SHELL_ZSH || mc_global.shell->type == SHELL_FISH)
+                    input_assign_text (cmdline, "");
                 subshell_ready = FALSE;
+            }
         }
         else
             return FALSE;
@@ -784 +1005 @@
     {
     case SHELL_BASH:
         g_snprintf (precmd, buff_size,
+                    " bind -x '\"\\033[98~\":\"echo $READLINE_LINE>&%d\"'\n"
+                    " bind -x '\"\\033[99~\":\"echo $READLINE_POINT>&%d\"'\n"
                     " PROMPT_COMMAND=${PROMPT_COMMAND:+$PROMPT_COMMAND\n}'pwd>&%d;kill -STOP $$'\n"
-                    "PS1='\\u@\\h:\\w\\$ '\n", subshell_pipe[WRITE]);
+                    "PS1='\\u@\\h:\\w\\$ '\n"
+        , command_buffer_pipe[WRITE], command_buffer_pipe[WRITE], subshell_pipe[WRITE]);
         break;
 
     case SHELL_ASH_BUSYBOX:
@@ -844 +1068 @@
 
     case SHELL_ZSH:
         g_snprintf (precmd, buff_size,
+                    " mc_print_command_buffer () { echo $BUFFER >&%d}\n"
+                    " zle -N mc_print_command_buffer\n"
+                    " bindkey '^[[98~' mc_print_command_buffer\n"
+                    " mc_print_cursor_position () { echo $CURSOR >&%d}\n"
+                    " zle -N mc_print_cursor_position\n"
+                    " bindkey '^[[99~' mc_print_cursor_position\n"
                     " _mc_precmd(){ pwd>&%d;kill -STOP $$ }; precmd_functions+=(_mc_precmd)\n"
-                    "PS1='%%n@%%m:%%~%%# '\n", subshell_pipe[WRITE]);
+                    "PS1='%%n@%%m:%%~%%# '\n", command_buffer_pipe[WRITE], command_buffer_pipe[WRITE], subshell_pipe[WRITE]);
         break;
 
     case SHELL_TCSH:
@@ -854 +1084 @@
                     "set prompt='%%n@%%m:%%~%%# '; "
                     "alias precmd 'echo $cwd:q >>%s; kill -STOP $$'\n", tcsh_fifo);
         break;
-
     case SHELL_FISH:
         g_snprintf (precmd, buff_size,
                     " if not functions -q fish_prompt_mc;"
                     "functions -e fish_right_prompt;"
                     "functions -c fish_prompt fish_prompt_mc; end;"
                     "function fish_prompt;"
+                    "bind \033\[98~ 'echo (commandline)>&%d'\n"
+                    "bind \033\[99~ 'echo (commandline -C)>&%d'\n"
                     "echo \"$PWD\">&%d; fish_prompt_mc; kill -STOP %%self; end\n",
-                    subshell_pipe[WRITE]);
+                    command_buffer_pipe[WRITE], command_buffer_pipe[WRITE], subshell_pipe[WRITE]);
         break;
 
     default:
@@ -1040 +1271 @@
             mc_global.tty.use_subshell = FALSE;
             return;
         }
+        if (mc_global.shell->type == SHELL_BASH || mc_global.shell->type == SHELL_ZSH || mc_global.shell->type == SHELL_FISH)
+        {
+            if (pipe (command_buffer_pipe))
+            {
+                perror (__FILE__ ": couldn't create pipe");
+                mc_global.tty.use_subshell = FALSE;
+                return;
+            }
+        }
     }
 
     /* Fork the subshell */
@@ -1061 +1301 @@
         /* We are in the child process */
         init_subshell_child (pty_name);
     }
-
     init_subshell_precmd (precmd, BUF_MEDIUM);
 
     write_all (mc_global.tty.subshell_pty, precmd, strlen (precmd));
@@ -1084 +1323 @@
 int
 invoke_subshell (const char *command, int how, vfs_path_t ** new_dir_vpath)
 {
+    size_t i;
     /* Make the MC terminal transparent */
     tcsetattr (STDOUT_FILENO, TCSANOW, &raw_mode);
 
@@ -1100 +1340 @@
             /* FIXME: possibly take out this hack; the user can re-play it by hitting C-hyphen a few times! */
             if (subshell_ready && mc_global.mc_run_mode == MC_RUN_FULL)
                 write_all (mc_global.tty.subshell_pty, " \b", 2);       /* Hack to make prompt reappear */
+ 
+            if (mc_global.shell->type == SHELL_BASH || mc_global.shell->type == SHELL_ZSH || mc_global.shell->type == SHELL_FISH)
+            {
+                /* Check to make sure there are no non text characters in the command buffer, such as tab, or newline, as this could cause problems. */
+                for(i = 0;i < strlen(cmdline->buffer);i++)
+                {
+                    if (!(cmdline->buffer[i] >= 32 && cmdline->buffer[i] <= 126))
+                        cmdline->buffer[i] = ' ';
+                }
+
+                /* Write the command buffer to the subshell. */
+                write_all (mc_global.tty.subshell_pty, cmdline->buffer, strlen (cmdline->buffer));
+
+                /* Put the cursor in the correct place in the subshell. */
+                for (i = 0;i < strlen (cmdline->buffer) - cmdline->point;i++)
+                    write_all (mc_global.tty.subshell_pty, "\033[D", 3);
+            }
         }
     }
     else                        /* MC has passed us a user command */
     {
+        /* Before we write to the command prompt, we need to clear whatever */
+        /* data is there, but only if we are using one of the shells that */
+        /* doesn't support keeping command buffer contents, OR if there was */
+        /* some sort of error. */
+        if (!(mc_global.shell->type == SHELL_BASH || mc_global.shell->type == SHELL_ZSH || mc_global.shell->type == SHELL_FISH) || subshell_should_clear_command_line)
+        {
+            write_all (mc_global.tty.subshell_pty, "\003", 1);
+            subshell_state = RUNNING_COMMAND;
+            if (mc_global.shell->type != SHELL_FISH)
+                feed_subshell (QUIETLY, FALSE);
+        }
         if (how == QUIETLY)
             write_all (mc_global.tty.subshell_pty, " ", 1);
         /* FIXME: if command is long (>8KB ?) we go comma */
@@ -1131 +1399 @@
     return subshell_get_mainloop_quit ();
 }
 
-
 /* --------------------------------------------------------------------------------------------- */
 
 gboolean
@@ -1140 +1407 @@
     int rc = 0;
     ssize_t bytes = 0;
     struct timeval timeleft = { 0, 0 };
-    GString *p;
-    gboolean prompt_was_reset = FALSE;
+    int should_reset_prompt = TRUE;
+    int got_new_prompt = FALSE;
 
     fd_set tmp;
     FD_ZERO (&tmp);
     FD_SET (mc_global.tty.subshell_pty, &tmp);
 
-    /* First time through */
-    if (subshell_prompt == NULL)
-        subshell_prompt = g_string_sized_new (INITIAL_PROMPT_SIZE);
-
-    p = g_string_sized_new (INITIAL_PROMPT_SIZE);
-
     while (subshell_alive
            && (rc = select (mc_global.tty.subshell_pty + 1, &tmp, NULL, NULL, &timeleft)) != 0)
     {
-        ssize_t i;
-
         /* Check for 'select' errors */
         if (rc == -1)
         {
@@ -1174 +1433 @@
         }
 
         bytes = read (mc_global.tty.subshell_pty, pty_buffer, sizeof (pty_buffer));
-
-        /* Extract the prompt from the shell output */
-        for (i = 0; i < bytes; i++)
-            if (pty_buffer[i] == '\n' || pty_buffer[i] == '\r')
-            {
-                g_string_set_size (p, 0);
-                prompt_was_reset = TRUE;
-            }
-            else if (pty_buffer[i] != '\0')
-                g_string_append_c (p, pty_buffer[i]);
+        if (should_reset_prompt)
+        {
+            should_reset_prompt = FALSE;
+            clear_subshell_prompt_string();
+        }
+        parse_subshell_prompt_string (pty_buffer, bytes);
+        got_new_prompt = TRUE;
+    }
+    if (got_new_prompt == TRUE)
+    {
+        set_prompt_string ();
     }
-
-    if (p->len != 0 || prompt_was_reset)
-        g_string_assign (subshell_prompt, p->str);
-
-    g_string_free (p, TRUE);
 
     return (rc != 0 || bytes != 0);
 }
@@ -1259 +1514 @@
         return;
     }
 
+    if (!(mc_global.shell->type == SHELL_BASH || mc_global.shell->type == SHELL_ZSH || mc_global.shell->type == SHELL_FISH) || subshell_should_clear_command_line)
+    {
+        write_all (mc_global.tty.subshell_pty, "\003", 1);
+        subshell_state = RUNNING_COMMAND;
+        if (mc_global.shell->type != SHELL_FISH)
+            feed_subshell (QUIETLY, FALSE);
+    }
     /* The initial space keeps this out of the command history (in bash
        because we set "HISTCONTROL=ignorespace") */
     write_all (mc_global.tty.subshell_pty, " cd ", 4);