src/command.c

   1 /* Command line widget.
   2    Copyright (C) 1995, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
   3    2007 Free Software Foundation, Inc.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software
  17    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18
  19    This widget is derived from the WInput widget, it's used to cope
  20    with all the magic of the command input line, we depend on some
  21    help from the program's callback.
  22
  23 */
  24
  25 /** \file command.c
  26  *  \brief Source: command line widget
  27  */
  28
  29 #include <config.h>
  30
  31 #include <stdlib.h>
  32 #include <errno.h>
  33 #include <string.h>
  34
  35 #include "lib/global.h"         /* home_dir */
  36 #include "lib/tty/tty.h"
  37 #include "lib/vfs/mc-vfs/vfs.h"
  38 #include "lib/strescape.h"
  39
  40 #include "widget.h"             /* WInput */
  41 #include "command.h"
  42 #include "wtools.h"             /* message () */
  43 #include "panel.h"              /* view_tree enum. Also, needed by main.h */
  44 #include "main.h"               /* do_cd */
  45 #include "layout.h"             /* for command_prompt variable */
  46 #include "user.h"               /* expand_format */
  47 #include "subshell.h"           /* SUBSHELL_EXIT */
  48 #include "tree.h"               /* for tree_chdir */
  49 #include "lib/skin.h"           /* DEFAULT_COLOR */
  50 #include "execute.h"            /* shell_execute */
  51
  52 /* This holds the command line */
  53 WInput *cmdline;
  54
  55 /*
  56  * Expand the argument to "cd" and change directory.  First try tilde
  57  * expansion, then variable substitution.  If the CDPATH variable is set
  58  * (e.g. CDPATH=".:~:/usr"), try all the paths contained there.
  59  * We do not support such rare substitutions as ${var:-value} etc.
  60  * No quoting is implemented here, so ${VAR} and $VAR will be always
  61  * substituted.  Wildcards are not supported either.
  62  * Advanced users should be encouraged to use "\cd" instead of "cd" if
  63  * they want the behavior they are used to in the shell.
  64  */
  65 static int
  66 examine_cd (const char *_path)
  67 {
  68     int result, qlen;
  69     char *path_tilde, *path;
  70     char *p, *q, *r, *s, c;
  71     const char *t;
  72
  73     /* Tilde expansion */
  74     path = strutils_shell_unescape(_path);
  75     path_tilde = tilde_expand (path);
  76
  77     /* Leave space for further expansion */
  78     qlen = strlen (path_tilde) + MC_MAXPATHLEN;
  79     q = g_malloc (qlen);
  80
  81     /* Variable expansion */
  82     for (p = path_tilde, r = q; *p && r < q + MC_MAXPATHLEN;) {
  83         if (*p != '$' || (p[1] == '[' || p[1] == '('))
  84             *(r++) = *(p++);
  85         else {
  86             p++;
  87             if (*p == '{') {
  88                 p++;
  89                 s = strchr (p, '}');
  90             } else
  91                 s = NULL;
  92             if (s == NULL)
  93                 s = strchr (p, PATH_SEP);
  94             if (s == NULL)
  95                 s = strchr (p, 0);
  96             c = *s;
  97             *s = 0;
  98             t = getenv (p);
  99             *s = c;
 100             if (t == NULL) {
 101                 *(r++) = '$';
 102                 if (*(p - 1) != '$')
 103                     *(r++) = '{';
 104             } else {
 105                 if (r + strlen (t) < q + MC_MAXPATHLEN) {
 106                     strcpy (r, t);
 107                     r = strchr (r, 0);
 108                 }
 109                 if (*s == '}')
 110                     p = s + 1;
 111                 else
 112                     p = s;
 113             }
 114         }
 115     }
 116     *r = 0;
 117
 118     result = do_cd (q, cd_parse_command);
 119
 120     /* CDPATH handling */
 121     if (*q != PATH_SEP && !result) {
 122         char * const cdpath = g_strdup (getenv ("CDPATH"));
 123         p = cdpath;
 124         if (p == NULL)
 125             c = 0;
 126         else
 127             c = ':';
 128         while (!result && c == ':') {
 129             s = strchr (p, ':');
 130             if (s == NULL)
 131                 s = strchr (p, 0);
 132             c = *s;
 133             *s = 0;
 134             if (*p) {
 135                 r = concat_dir_and_file (p, q);
 136                 result = do_cd (r, cd_parse_command);
 137                 g_free (r);
 138             }
 139             *s = c;
 140             p = s + 1;
 141         }
 142         g_free (cdpath);
 143     }
 144     g_free (q);
 145     g_free (path_tilde);
 146     g_free (path);
 147     return result;
 148 }
 149
 150 /* Execute the cd command on the command line */
 151 void do_cd_command (char * orig_cmd)
 152 {
 153     int len;
 154     const char * cmd;
 155
 156     /* Any final whitespace should be removed here
 157        (to see why, try "cd fred "). */
 158     /* NOTE: I think we should not remove the extra space,
 159        that way, we can cd into hidden directories */
 160     /* FIXME: what about interpreting quoted strings like the shell.
 161        so one could type "cd <tab> M-a <enter>" and it would work. */
 162     len = strlen (orig_cmd) - 1;
 163     while (len >= 0 &&
 164            (orig_cmd [len] == ' ' || orig_cmd [len] == '\t' || orig_cmd [len] == '\n')){
 165         orig_cmd [len] = 0;
 166         len --;
 167     }
 168
 169     cmd = orig_cmd;
 170     if (cmd [2] == 0)
 171         cmd = "cd ";
 172
 173     if (get_current_type () == view_tree){
 174         if (cmd [0] == 0){
 175             sync_tree (home_dir);
 176         } else if (strcmp (cmd+3, "..") == 0){
 177             char *dir = current_panel->cwd;
 178             len = strlen (dir);
 179             while (len && dir [--len] != PATH_SEP);
 180             dir [len] = 0;
 181             if (len)
 182                 sync_tree (dir);
 183             else
 184                 sync_tree (PATH_SEP_STR);
 185         } else if (cmd [3] == PATH_SEP){
 186             sync_tree (cmd+3);
 187         } else {
 188             char *old = current_panel->cwd;
 189             char *new;
 190             new = concat_dir_and_file (old, cmd+3);
 191             sync_tree (new);
 192             g_free (new);
 193         }
 194     } else
 195         if (!examine_cd (&cmd [3])) {
 196             char *d = strip_password (g_strdup (&cmd [3]), 1);
 197             message (D_ERROR, MSG_ERROR, _("Cannot chdir to \"%s\"\n%s"),
 198                      d, unix_error_string (errno));
 199             g_free (d);
 200             return;
 201         }
 202 }
 203
 204 /* Handle Enter on the command line */
 205 static cb_ret_t
 206 enter (WInput *lc_cmdline)
 207 {
 208     char *cmd = lc_cmdline->buffer;
 209
 210     if (!command_prompt)
 211         return MSG_HANDLED;
 212
 213     /* Any initial whitespace should be removed at this point */
 214     while (*cmd == ' ' || *cmd == '\t' || *cmd == '\n')
 215         cmd++;
 216
 217     if (!*cmd)
 218         return MSG_HANDLED;
 219
 220     if (strncmp (cmd, "cd ", 3) == 0 || strcmp (cmd, "cd") == 0) {
 221         do_cd_command (cmd);
 222         new_input (lc_cmdline);
 223         return MSG_HANDLED;
 224     } else {
 225         char *command, *s;
 226         size_t i, j, cmd_len;
 227
 228         if (!vfs_current_is_local ()) {
 229             if (strcmp (cmd, "exit") == 0) {
 230                 quiet_quit_cmd ();
 231                 return MSG_HANDLED;
 232             }
 233
 234             message (D_ERROR, MSG_ERROR,
 235                      _("Cannot execute commands on non-local filesystems"));
 236
 237             return MSG_NOT_HANDLED;
 238         }
 239 #ifdef HAVE_SUBSHELL_SUPPORT
 240         /* Check this early before we clean command line
 241          * (will be checked again by shell_execute) */
 242         if (use_subshell && subshell_state != INACTIVE) {
 243             message (D_ERROR, MSG_ERROR,
 244                      _("The shell is already running a command"));
 245             return MSG_NOT_HANDLED;
 246         }
 247 #endif
 248         cmd_len = strlen (cmd);
 249         command = g_malloc (cmd_len + 1);
 250         command[0] = 0;
 251         for (i = j = 0; i < cmd_len; i++) {
 252             if (cmd[i] == '%') {
 253                 i++;
 254                 s = expand_format (NULL, cmd[i], TRUE);
 255                 command = g_realloc (command, j + strlen (s) + cmd_len - i + 1);
 256                 strcpy (command + j, s);
 257                 g_free (s);
 258                 j = strlen (command);
 259             } else {
 260                 command[j] = cmd[i];
 261                 j++;
 262             }
 263             command[j] = 0;
 264         }
 265         new_input (lc_cmdline);
 266         shell_execute (command, 0);
 267         g_free (command);
 268
 269 #ifdef HAVE_SUBSHELL_SUPPORT
 270         if (quit & SUBSHELL_EXIT) {
 271             quiet_quit_cmd ();
 272             return MSG_HANDLED;
 273         }
 274         if (use_subshell)
 275             load_prompt (0, 0);
 276 #endif
 277     }
 278     return MSG_HANDLED;
 279 }
 280
 281 static cb_ret_t
 282 command_callback (Widget *w, widget_msg_t msg, int parm)
 283 {
 284     WInput *cmd = (WInput *) w;
 285
 286     switch (msg) {
 287     case WIDGET_FOCUS:
 288         /* Never accept focus, otherwise panels will be unselected */
 289         return MSG_NOT_HANDLED;
 290
 291     case WIDGET_KEY:
 292         /* Special case: we handle the enter key */
 293         if (parm == '\n') {
 294             return enter (cmd);
 295         }
 296         /* fall through */
 297
 298     default:
 299         return input_callback (w, msg, parm);
 300     }
 301 }
 302
 303 WInput *
 304 command_new (int y, int x, int cols)
 305 {
 306     WInput *cmd;
 307     const int command_colors[3] =
 308     {
 309         DEFAULT_COLOR,
 310         DEFAULT_COLOR,
 311         COMMAND_MARK_COLOR
 312     };
 313
 314     cmd = input_new (y, x, (int *) command_colors, cols, "", "cmdline",
 315         INPUT_COMPLETE_DEFAULT | INPUT_COMPLETE_CD | INPUT_COMPLETE_COMMANDS | INPUT_COMPLETE_SHELL_ESC);
 316
 317     /* Add our hooks */
 318     cmd->widget.callback = command_callback;
 319
 320     return cmd;
 321 }
 322
 323 /*
 324  * Insert quoted text in input line.  The function is meant for the
 325  * command line, so the percent sign is quoted as well.
 326  */
 327 void
 328 command_insert (WInput * in, const char *text, int insert_extra_space)
 329 {
 330     char *quoted_text;
 331
 332     quoted_text = name_quote (text, 1);
 333     stuff (in, quoted_text, insert_extra_space);
 334     g_free (quoted_text);
 335 }
 336