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 #include "lib/skin.h"           /* DEFAULT_COLOR */
  40 #include "lib/util.h"
  41 #include "lib/widget.h"
  42
  43 #include "midnight.h"           /* current_panel */
  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 "execute.h"            /* shell_execute */
  50
  51 #include "command.h"
  52
  53 /*** global variables ****************************************************************************/
  54
  55 /* This holds the command line */
  56 WInput *cmdline;
  57
  58 /*** file scope macro definitions ****************************************************************/
  59
  60 /*** file scope type declarations ****************************************************************/
  61
  62 /*** file scope variables ************************************************************************/
  63
  64 /*** file scope functions ************************************************************************/
  65 /* --------------------------------------------------------------------------------------------- */
  66
  67 /**
  68  * Expand the argument to "cd" and change directory.  First try tilde
  69  * expansion, then variable substitution.  If the CDPATH variable is set
  70  * (e.g. CDPATH=".:~:/usr"), try all the paths contained there.
  71  * We do not support such rare substitutions as ${var:-value} etc.
  72  * No quoting is implemented here, so ${VAR} and $VAR will be always
  73  * substituted.  Wildcards are not supported either.
  74  * Advanced users should be encouraged to use "\cd" instead of "cd" if
  75  * they want the behavior they are used to in the shell.
  76  */
  77
  78 static int
  79 examine_cd (const char *_path)
  80 {
  81     int result, qlen;
  82     char *path_tilde, *path;
  83     char *p, *q, *r, *s, c;
  84     const char *t;
  85
  86     /* Tilde expansion */
  87     path = strutils_shell_unescape (_path);
  88     path_tilde = tilde_expand (path);
  89
  90     /* Leave space for further expansion */
  91     qlen = strlen (path_tilde) + MC_MAXPATHLEN;
  92     q = g_malloc (qlen);
  93
  94     /* Variable expansion */
  95     for (p = path_tilde, r = q; *p && r < q + MC_MAXPATHLEN;)
  96     {
  97         if (*p != '$' || (p[1] == '[' || p[1] == '('))
  98             *(r++) = *(p++);
  99         else
 100         {
 101             p++;
 102             if (*p == '{')
 103             {
 104                 p++;
 105                 s = strchr (p, '}');
 106             }
 107             else
 108                 s = NULL;
 109             if (s == NULL)
 110                 s = strchr (p, PATH_SEP);
 111             if (s == NULL)
 112                 s = strchr (p, 0);
 113             c = *s;
 114             *s = 0;
 115             t = getenv (p);
 116             *s = c;
 117             if (t == NULL)
 118             {
 119                 *(r++) = '$';
 120                 if (*(p - 1) != '$')
 121                     *(r++) = '{';
 122             }
 123             else
 124             {
 125                 if (r + strlen (t) < q + MC_MAXPATHLEN)
 126                 {
 127                     strcpy (r, t);
 128                     r = strchr (r, 0);
 129                 }
 130                 if (*s == '}')
 131                     p = s + 1;
 132                 else
 133                     p = s;
 134             }
 135         }
 136     }
 137     *r = 0;
 138
 139     result = do_cd (q, cd_parse_command);
 140
 141     /* CDPATH handling */
 142     if (*q != PATH_SEP && !result)
 143     {
 144         char *const cdpath = g_strdup (getenv ("CDPATH"));
 145         p = cdpath;
 146         if (p == NULL)
 147             c = 0;
 148         else
 149             c = ':';
 150         while (!result && c == ':')
 151         {
 152             s = strchr (p, ':');
 153             if (s == NULL)
 154                 s = strchr (p, 0);
 155             c = *s;
 156             *s = 0;
 157             if (*p)
 158             {
 159                 r = concat_dir_and_file (p, q);
 160                 result = do_cd (r, cd_parse_command);
 161                 g_free (r);
 162             }
 163             *s = c;
 164             p = s + 1;
 165         }
 166         g_free (cdpath);
 167     }
 168     g_free (q);
 169     g_free (path_tilde);
 170     g_free (path);
 171     return result;
 172 }
 173
 174 /* --------------------------------------------------------------------------------------------- */
 175 /** Handle Enter on the command line */
 176
 177 static cb_ret_t
 178 enter (WInput * lc_cmdline)
 179 {
 180     char *cmd = lc_cmdline->buffer;
 181
 182     if (!command_prompt)
 183         return MSG_HANDLED;
 184
 185     /* Any initial whitespace should be removed at this point */
 186     while (*cmd == ' ' || *cmd == '\t' || *cmd == '\n')
 187         cmd++;
 188
 189     if (!*cmd)
 190         return MSG_HANDLED;
 191
 192     if (strncmp (cmd, "cd ", 3) == 0 || strcmp (cmd, "cd") == 0)
 193     {
 194         do_cd_command (cmd);
 195         input_clean (lc_cmdline);
 196         return MSG_HANDLED;
 197     }
 198     else if (strcmp (cmd, "exit") == 0)
 199     {
 200         input_assign_text (lc_cmdline, "");
 201         if (!quiet_quit_cmd ())
 202             return MSG_NOT_HANDLED;
 203     }
 204     else
 205     {
 206         char *command, *s;
 207         size_t i, j, cmd_len;
 208
 209         if (!vfs_current_is_local ())
 210         {
 211             message (D_ERROR, MSG_ERROR, _("Cannot execute commands on non-local filesystems"));
 212             return MSG_NOT_HANDLED;
 213         }
 214 #ifdef HAVE_SUBSHELL_SUPPORT
 215         /* Check this early before we clean command line
 216          * (will be checked again by shell_execute) */
 217         if (use_subshell && subshell_state != INACTIVE)
 218         {
 219             message (D_ERROR, MSG_ERROR, _("The shell is already running a command"));
 220             return MSG_NOT_HANDLED;
 221         }
 222 #endif
 223         cmd_len = strlen (cmd);
 224         command = g_malloc (cmd_len + 1);
 225         command[0] = 0;
 226         for (i = j = 0; i < cmd_len; i++)
 227         {
 228             if (cmd[i] == '%')
 229             {
 230                 i++;
 231                 s = expand_format (NULL, cmd[i], TRUE);
 232                 command = g_realloc (command, j + strlen (s) + cmd_len - i + 1);
 233                 strcpy (command + j, s);
 234                 g_free (s);
 235                 j = strlen (command);
 236             }
 237             else
 238             {
 239                 command[j] = cmd[i];
 240                 j++;
 241             }
 242             command[j] = 0;
 243         }
 244         input_clean (lc_cmdline);
 245         shell_execute (command, 0);
 246         g_free (command);
 247
 248 #ifdef HAVE_SUBSHELL_SUPPORT
 249         if ((quit & SUBSHELL_EXIT) != 0)
 250         {
 251             if (quiet_quit_cmd ())
 252                 return MSG_HANDLED;
 253
 254             quit = 0;
 255             /* restart subshell */
 256             if (use_subshell)
 257                 init_subshell ();
 258         }
 259
 260         if (use_subshell)
 261             load_prompt (0, NULL);
 262 #endif
 263     }
 264     return MSG_HANDLED;
 265 }
 266
 267 /* --------------------------------------------------------------------------------------------- */
 268
 269 static cb_ret_t
 270 command_callback (Widget * w, widget_msg_t msg, int parm)
 271 {
 272     WInput *cmd = (WInput *) w;
 273
 274     switch (msg)
 275     {
 276     case WIDGET_FOCUS:
 277         /* Never accept focus, otherwise panels will be unselected */
 278         return MSG_NOT_HANDLED;
 279
 280     case WIDGET_KEY:
 281         /* Special case: we handle the enter key */
 282         if (parm == '\n')
 283         {
 284             return enter (cmd);
 285         }
 286         /* fall through */
 287
 288     default:
 289         return input_callback (w, msg, parm);
 290     }
 291 }
 292
 293 /* --------------------------------------------------------------------------------------------- */
 294 /*** public functions ****************************************************************************/
 295 /* --------------------------------------------------------------------------------------------- */
 296
 297 /* --------------------------------------------------------------------------------------------- */
 298 /** Execute the cd command on the command line */
 299
 300 void
 301 do_cd_command (char *orig_cmd)
 302 {
 303     int len;
 304     const char *cmd;
 305
 306     /* Any final whitespace should be removed here
 307        (to see why, try "cd fred "). */
 308     /* NOTE: I think we should not remove the extra space,
 309        that way, we can cd into hidden directories */
 310     /* FIXME: what about interpreting quoted strings like the shell.
 311        so one could type "cd <tab> M-a <enter>" and it would work. */
 312     len = strlen (orig_cmd) - 1;
 313     while (len >= 0 && (orig_cmd[len] == ' ' || orig_cmd[len] == '\t' || orig_cmd[len] == '\n'))
 314     {
 315         orig_cmd[len] = 0;
 316         len--;
 317     }
 318
 319     cmd = orig_cmd;
 320     if (cmd[2] == 0)
 321         cmd = "cd ";
 322
 323     if (get_current_type () == view_tree)
 324     {
 325         if (cmd[0] == 0)
 326         {
 327             sync_tree (home_dir);
 328         }
 329         else if (strcmp (cmd + 3, "..") == 0)
 330         {
 331             char *dir = current_panel->cwd;
 332             len = strlen (dir);
 333             while (len && dir[--len] != PATH_SEP);
 334             dir[len] = 0;
 335             if (len)
 336                 sync_tree (dir);
 337             else
 338                 sync_tree (PATH_SEP_STR);
 339         }
 340         else if (cmd[3] == PATH_SEP)
 341         {
 342             sync_tree (cmd + 3);
 343         }
 344         else
 345         {
 346             char *old = current_panel->cwd;
 347             char *new;
 348             new = concat_dir_and_file (old, cmd + 3);
 349             sync_tree (new);
 350             g_free (new);
 351         }
 352     }
 353     else if (!examine_cd (&cmd[3]))
 354     {
 355         char *d = strip_password (g_strdup (&cmd[3]), 1);
 356         message (D_ERROR, MSG_ERROR, _("Cannot chdir to \"%s\"\n%s"), d, unix_error_string (errno));
 357         g_free (d);
 358         return;
 359     }
 360 }
 361
 362 /* --------------------------------------------------------------------------------------------- */
 363
 364 WInput *
 365 command_new (int y, int x, int cols)
 366 {
 367     WInput *cmd;
 368     const input_colors_t command_colors = {
 369         DEFAULT_COLOR,
 370         COMMAND_MARK_COLOR,
 371         DEFAULT_COLOR,
 372         COMMAND_HISTORY_COLOR
 373     };
 374
 375     cmd = input_new (y, x, (int *) command_colors, cols, "", "cmdline",
 376                      INPUT_COMPLETE_DEFAULT | INPUT_COMPLETE_CD | INPUT_COMPLETE_COMMANDS |
 377                      INPUT_COMPLETE_SHELL_ESC);
 378
 379     /* Add our hooks */
 380     cmd->widget.callback = command_callback;
 381
 382     return cmd;
 383 }
 384
 385 /* --------------------------------------------------------------------------------------------- */
 386 /**
 387  * Insert quoted text in input line.  The function is meant for the
 388  * command line, so the percent sign is quoted as well.
 389  */
 390
 391 void
 392 command_insert (WInput * in, const char *text, gboolean insert_extra_space)
 393 {
 394     char *quoted_text;
 395
 396     quoted_text = name_quote (text, 1);
 397     input_insert (in, quoted_text, insert_extra_space);
 398     g_free (quoted_text);
 399 }
 400
 401 /* --------------------------------------------------------------------------------------------- */