src/execute.c

   1 /*
   2    Execution routines for GNU Midnight Commander
   3
   4    Copyright (C) 2003, 2004, 2005, 2007, 2011
   5    The Free Software Foundation, Inc.
   6
   7    This file is part of the Midnight Commander.
   8
   9    The Midnight Commander is free software: you can redistribute it
  10    and/or modify it under the terms of the GNU General Public License as
  11    published by the Free Software Foundation, either version 3 of the License,
  12    or (at your option) any later version.
  13
  14    The Midnight Commander is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21  */
  22
  23 /** \file  execute.c
  24  *  \brief Source: execution routines
  25  */
  26
  27 #include <config.h>
  28
  29 #include <signal.h>
  30 #include <string.h>
  31 #include <sys/stat.h>
  32 #include <sys/time.h>
  33
  34 #include "lib/global.h"
  35
  36 #include "lib/tty/tty.h"
  37 #include "lib/tty/key.h"
  38 #include "lib/tty/win.h"
  39 #include "lib/vfs/vfs.h"
  40 #include "lib/mcconfig.h"
  41 #include "lib/util.h"
  42 #include "lib/strutil.h"        /* str_replace_all_substrings() */
  43 #include "lib/widget.h"
  44
  45 #include "filemanager/midnight.h"
  46 #include "filemanager/layout.h" /* use_dash() */
  47 #include "consaver/cons.saver.h"
  48 #ifdef ENABLE_SUBSHELL
  49 #include "subshell.h"
  50 #endif
  51 #include "setup.h"              /* clear_before_exec */
  52
  53 #include "execute.h"
  54
  55 /*** global variables ****************************************************************************/
  56
  57 int pause_after_run = pause_on_dumb_terminals;
  58
  59 /*** file scope macro definitions ****************************************************************/
  60
  61 /*** file scope type declarations ****************************************************************/
  62
  63 /*** file scope variables ************************************************************************/
  64
  65 /*** file scope functions ************************************************************************/
  66
  67 void do_execute (const char *shell, const char *command, int flags);
  68 void do_executev (const char *shell, int flags, char *const argv[]);
  69 char *execute_get_external_cmd_opts_from_config (const char *command,
  70                                                  const vfs_path_t * filename_vpath,
  71                                                  long start_line);
  72
  73 /* --------------------------------------------------------------------------------------------- */
  74
  75 static void
  76 edition_post_exec (void)
  77 {
  78     do_enter_ca_mode ();
  79
  80     /* FIXME: Missing on slang endwin? */
  81     tty_reset_prog_mode ();
  82     tty_flush_input ();
  83
  84     tty_keypad (TRUE);
  85     tty_raw_mode ();
  86     channels_up ();
  87     enable_mouse ();
  88     if (mc_global.tty.alternate_plus_minus)
  89         application_keypad_mode ();
  90 }
  91
  92 /* --------------------------------------------------------------------------------------------- */
  93
  94 static void
  95 edition_pre_exec (void)
  96 {
  97     if (clear_before_exec)
  98         clr_scr ();
  99     else
 100     {
 101         if (!(mc_global.tty.console_flag != '\0' || mc_global.tty.xterm_flag))
 102             printf ("\n\n");
 103     }
 104
 105     channels_down ();
 106     disable_mouse ();
 107
 108     tty_reset_shell_mode ();
 109     tty_keypad (FALSE);
 110     tty_reset_screen ();
 111
 112     numeric_keypad_mode ();
 113
 114     /* on xterms: maybe endwin did not leave the terminal on the shell
 115      * screen page: do it now.
 116      *
 117      * Do not move this before endwin: in some systems rmcup includes
 118      * a call to clear screen, so it will end up clearing the shell screen.
 119      */
 120     do_exit_ca_mode ();
 121 }
 122
 123 /* --------------------------------------------------------------------------------------------- */
 124
 125 #ifdef ENABLE_SUBSHELL
 126 static void
 127 do_possible_cd (const vfs_path_t * new_dir_vpath)
 128 {
 129     if (!do_cd (new_dir_vpath, cd_exact))
 130         message (D_ERROR, _("Warning"),
 131                  _("The Commander can't change to the directory that\n"
 132                    "the subshell claims you are in. Perhaps you have\n"
 133                    "deleted your working directory, or given yourself\n"
 134                    "extra access permissions with the \"su\" command?"));
 135 }
 136 #endif /* ENABLE_SUBSHELL */
 137
 138 /* --------------------------------------------------------------------------------------------- */
 139
 140 static void
 141 do_suspend_cmd (void)
 142 {
 143     pre_exec ();
 144
 145     if (mc_global.tty.console_flag != '\0' && !mc_global.tty.use_subshell)
 146         handle_console (CONSOLE_RESTORE);
 147
 148 #ifdef SIGTSTP
 149     {
 150         struct sigaction sigtstp_action;
 151
 152         /* Make sure that the SIGTSTP below will suspend us directly,
 153            without calling ncurses' SIGTSTP handler; we *don't* want
 154            ncurses to redraw the screen immediately after the SIGCONT */
 155         sigaction (SIGTSTP, &startup_handler, &sigtstp_action);
 156
 157         kill (getpid (), SIGTSTP);
 158
 159         /* Restore previous SIGTSTP action */
 160         sigaction (SIGTSTP, &sigtstp_action, NULL);
 161     }
 162 #endif /* SIGTSTP */
 163
 164     if (mc_global.tty.console_flag != '\0' && !mc_global.tty.use_subshell)
 165         handle_console (CONSOLE_SAVE);
 166
 167     edition_post_exec ();
 168 }
 169
 170 /* --------------------------------------------------------------------------------------------- */
 171
 172 static gboolean
 173 execute_prepare_with_vfs_arg (const vfs_path_t * filename_vpath, vfs_path_t ** localcopy_vpath,
 174                               time_t * mtime)
 175 {
 176     struct stat st;
 177
 178     /* Simplest case, this file is local */
 179     if ((filename_vpath == NULL && vfs_file_is_local (vfs_get_raw_current_dir ()))
 180         || vfs_file_is_local (filename_vpath))
 181         return TRUE;
 182
 183     /* FIXME: Creation of new files on VFS is not supported */
 184     if (filename_vpath == NULL)
 185         return FALSE;
 186
 187     *localcopy_vpath = mc_getlocalcopy (filename_vpath);
 188     if (*localcopy_vpath == NULL)
 189     {
 190         char *filename;
 191
 192         filename = vfs_path_to_str (filename_vpath);
 193         message (D_ERROR, MSG_ERROR, _("Cannot fetch a local copy of %s"), filename);
 194         g_free (filename);
 195         return FALSE;
 196     }
 197
 198     mc_stat (*localcopy_vpath, &st);
 199     *mtime = st.st_mtime;
 200     return TRUE;
 201 }
 202
 203 /* --------------------------------------------------------------------------------------------- */
 204
 205 static void
 206 execute_cleanup_with_vfs_arg (const vfs_path_t * filename_vpath, vfs_path_t ** localcopy_vpath,
 207                               time_t * mtime)
 208 {
 209     if (*localcopy_vpath != NULL)
 210     {
 211         struct stat st;
 212
 213         /*
 214          * filename can be an entry on panel, it can be changed by executing
 215          * the command, so make a copy.  Smarter VFS code would make the code
 216          * below unnecessary.
 217          */
 218         mc_stat (*localcopy_vpath, &st);
 219         mc_ungetlocalcopy (filename_vpath, *localcopy_vpath, *mtime != st.st_mtime);
 220         vfs_path_free (*localcopy_vpath);
 221         *localcopy_vpath = NULL;
 222     }
 223 }
 224
 225 /* --------------------------------------------------------------------------------------------- */
 226
 227 static char *
 228 execute_get_opts_from_cfg (const char *command, const char *default_str)
 229 {
 230     char *str_from_config;
 231
 232     str_from_config =
 233         mc_config_get_string_raw (mc_main_config, CONFIG_EXT_EDITOR_VIEWER_SECTION, command, NULL);
 234
 235     if (str_from_config == NULL)
 236     {
 237         mc_config_t *cfg;
 238
 239         cfg = mc_config_init (global_profile_name, TRUE);
 240         if (cfg == NULL)
 241             return g_strdup (default_str);
 242
 243         str_from_config =
 244             mc_config_get_string_raw (cfg, CONFIG_EXT_EDITOR_VIEWER_SECTION, command, default_str);
 245
 246         mc_config_deinit (cfg);
 247     }
 248
 249     return str_from_config;
 250 }
 251
 252 /* --------------------------------------------------------------------------------------------- */
 253 /*** public functions ****************************************************************************/
 254 /* --------------------------------------------------------------------------------------------- */
 255
 256 char *
 257 execute_get_external_cmd_opts_from_config (const char *command, const vfs_path_t * filename_vpath,
 258                                            long start_line)
 259 {
 260     char *str_from_config, *return_str;
 261     char *parameter;
 262
 263     if (filename_vpath == NULL)
 264         return g_strdup ("");
 265
 266     str_from_config = execute_get_opts_from_cfg (command, "%filename");
 267
 268     parameter = g_shell_quote (vfs_path_get_last_path_str (filename_vpath));
 269     return_str = str_replace_all (str_from_config, "%filename", parameter);
 270     g_free (parameter);
 271     g_free (str_from_config);
 272     str_from_config = return_str;
 273
 274     parameter = g_strdup_printf ("%ld", start_line);
 275     return_str = str_replace_all (str_from_config, "%lineno", parameter);
 276     g_free (parameter);
 277     g_free (str_from_config);
 278
 279     return return_str;
 280 }
 281
 282 /* --------------------------------------------------------------------------------------------- */
 283
 284 void
 285 do_executev (const char *shell, int flags, char *const argv[])
 286 {
 287 #ifdef ENABLE_SUBSHELL
 288     vfs_path_t *new_dir_vpath = NULL;
 289 #endif /* ENABLE_SUBSHELL */
 290
 291     vfs_path_t *old_vfs_dir_vpath = NULL;
 292
 293     if (!vfs_current_is_local ())
 294         old_vfs_dir_vpath = vfs_path_clone (vfs_get_raw_current_dir ());
 295
 296     if (mc_global.mc_run_mode == MC_RUN_FULL)
 297         save_cwds_stat ();
 298     pre_exec ();
 299     if (mc_global.tty.console_flag != '\0')
 300         handle_console (CONSOLE_RESTORE);
 301
 302     if (!mc_global.tty.use_subshell && *argv != NULL && (flags & EXECUTE_INTERNAL) == 0)
 303     {
 304         printf ("%s%s\n", mc_prompt, *argv);
 305         fflush (stdout);
 306     }
 307 #ifdef ENABLE_SUBSHELL
 308     if (mc_global.tty.use_subshell && (flags & EXECUTE_INTERNAL) == 0)
 309     {
 310         do_update_prompt ();
 311
 312         /* We don't care if it died, higher level takes care of this */
 313         invoke_subshell (*argv, VISIBLY, old_vfs_dir_vpath != NULL ? NULL : &new_dir_vpath);
 314     }
 315     else
 316 #endif /* ENABLE_SUBSHELL */
 317         my_systemv_flags (flags, shell, argv);
 318
 319     if ((flags & EXECUTE_INTERNAL) == 0)
 320     {
 321         if ((pause_after_run == pause_always
 322              || (pause_after_run == pause_on_dumb_terminals && !mc_global.tty.xterm_flag
 323                  && mc_global.tty.console_flag == '\0')) && quit == 0
 324 #ifdef ENABLE_SUBSHELL
 325             && subshell_state != RUNNING_COMMAND
 326 #endif /* ENABLE_SUBSHELL */
 327             )
 328         {
 329             printf (_("Press any key to continue..."));
 330             fflush (stdout);
 331             tty_raw_mode ();
 332             get_key_code (0);
 333             printf ("\r\n");
 334             fflush (stdout);
 335         }
 336         if (mc_global.tty.console_flag != '\0' && output_lines != 0 && mc_global.keybar_visible)
 337         {
 338             putchar ('\n');
 339             fflush (stdout);
 340         }
 341     }
 342
 343     if (mc_global.tty.console_flag != '\0')
 344         handle_console (CONSOLE_SAVE);
 345     edition_post_exec ();
 346
 347 #ifdef ENABLE_SUBSHELL
 348     if (new_dir_vpath != NULL)
 349     {
 350         do_possible_cd (new_dir_vpath);
 351         vfs_path_free (new_dir_vpath);
 352     }
 353
 354 #endif /* ENABLE_SUBSHELL */
 355
 356     if (old_vfs_dir_vpath != NULL)
 357     {
 358         mc_chdir (old_vfs_dir_vpath);
 359         vfs_path_free (old_vfs_dir_vpath);
 360     }
 361
 362     if (mc_global.mc_run_mode == MC_RUN_FULL)
 363     {
 364         update_panels (UP_OPTIMIZE, UP_KEEPSEL);
 365         update_xterm_title_path ();
 366     }
 367
 368     do_refresh ();
 369     use_dash (TRUE);
 370 }
 371
 372 /* --------------------------------------------------------------------------------------------- */
 373
 374 void
 375 do_execute (const char *shell, const char *command, int flags)
 376 {
 377     GPtrArray *args_array;
 378
 379     args_array = g_ptr_array_new ();
 380     g_ptr_array_add (args_array, (char *) command);
 381     g_ptr_array_add (args_array, NULL);
 382
 383     do_executev (shell, flags, (char *const *) args_array->pdata);
 384
 385     g_ptr_array_free (args_array, TRUE);
 386 }
 387
 388 /* --------------------------------------------------------------------------------------------- */
 389
 390 /** Set up the terminal before executing a program */
 391
 392 void
 393 pre_exec (void)
 394 {
 395     use_dash (FALSE);
 396     edition_pre_exec ();
 397 }
 398
 399 /* --------------------------------------------------------------------------------------------- */
 400 /** Hide the terminal after executing a program */
 401 void
 402 post_exec (void)
 403 {
 404     edition_post_exec ();
 405     use_dash (TRUE);
 406     repaint_screen ();
 407 }
 408
 409 /* --------------------------------------------------------------------------------------------- */
 410 /* Executes a command */
 411
 412 void
 413 shell_execute (const char *command, int flags)
 414 {
 415     char *cmd = NULL;
 416
 417     if (flags & EXECUTE_HIDE)
 418     {
 419         cmd = g_strconcat (" ", command, (char *) NULL);
 420         flags ^= EXECUTE_HIDE;
 421     }
 422
 423 #ifdef ENABLE_SUBSHELL
 424     if (mc_global.tty.use_subshell)
 425         if (subshell_state == INACTIVE)
 426             do_execute (mc_global.tty.shell, cmd ? cmd : command, flags | EXECUTE_AS_SHELL);
 427         else
 428             message (D_ERROR, MSG_ERROR, _("The shell is already running a command"));
 429     else
 430 #endif /* ENABLE_SUBSHELL */
 431         do_execute (mc_global.tty.shell, cmd ? cmd : command, flags | EXECUTE_AS_SHELL);
 432
 433     g_free (cmd);
 434 }
 435
 436 /* --------------------------------------------------------------------------------------------- */
 437
 438 void
 439 exec_shell (void)
 440 {
 441     do_execute (mc_global.tty.shell, 0, 0);
 442 }
 443
 444 /* --------------------------------------------------------------------------------------------- */
 445
 446 void
 447 toggle_panels (void)
 448 {
 449 #ifdef ENABLE_SUBSHELL
 450     vfs_path_t *new_dir_vpath = NULL;
 451     vfs_path_t **new_dir_p;
 452 #endif /* ENABLE_SUBSHELL */
 453
 454     SIG_ATOMIC_VOLATILE_T was_sigwinch = 0;
 455
 456     channels_down ();
 457     disable_mouse ();
 458     if (clear_before_exec)
 459         clr_scr ();
 460     if (mc_global.tty.alternate_plus_minus)
 461         numeric_keypad_mode ();
 462 #ifndef HAVE_SLANG
 463     /* With slang we don't want any of this, since there
 464      * is no raw_mode supported
 465      */
 466     tty_reset_shell_mode ();
 467 #endif /* !HAVE_SLANG */
 468     tty_noecho ();
 469     tty_keypad (FALSE);
 470     tty_reset_screen ();
 471     do_exit_ca_mode ();
 472     tty_raw_mode ();
 473     if (mc_global.tty.console_flag != '\0')
 474         handle_console (CONSOLE_RESTORE);
 475
 476 #ifdef ENABLE_SUBSHELL
 477     if (mc_global.tty.use_subshell)
 478     {
 479         new_dir_p = vfs_current_is_local ()? &new_dir_vpath : NULL;
 480         invoke_subshell (NULL, VISIBLY, new_dir_p);
 481     }
 482     else
 483 #endif /* ENABLE_SUBSHELL */
 484     {
 485         if (output_starts_shell)
 486         {
 487             fprintf (stderr, _("Type `exit' to return to the Midnight Commander"));
 488             fprintf (stderr, "\n\r\n\r");
 489
 490             my_system (EXECUTE_INTERNAL, mc_global.tty.shell, NULL);
 491         }
 492         else
 493             get_key_code (0);
 494     }
 495
 496     if (mc_global.tty.console_flag != '\0')
 497         handle_console (CONSOLE_SAVE);
 498
 499     do_enter_ca_mode ();
 500
 501     tty_reset_prog_mode ();
 502     tty_keypad (TRUE);
 503
 504     /* Prevent screen flash when user did 'exit' or 'logout' within
 505        subshell */
 506     if ((quit & SUBSHELL_EXIT) != 0)
 507     {
 508         /* User did `exit' or `logout': quit MC */
 509         if (quiet_quit_cmd ())
 510             return;
 511
 512         quit = 0;
 513 #ifdef ENABLE_SUBSHELL
 514         /* restart subshell */
 515         if (mc_global.tty.use_subshell)
 516             init_subshell ();
 517 #endif /* ENABLE_SUBSHELL */
 518     }
 519
 520     enable_mouse ();
 521     channels_up ();
 522     if (mc_global.tty.alternate_plus_minus)
 523         application_keypad_mode ();
 524
 525     /* HACK:
 526      * Save sigwinch flag that will be reset in mc_refresh() called via update_panels().
 527      * There is some problem with screen redraw in ncurses-based mc in this situation.
 528      */
 529     was_sigwinch = mc_global.tty.winch_flag;
 530     mc_global.tty.winch_flag = 0;
 531
 532 #ifdef ENABLE_SUBSHELL
 533     if (mc_global.tty.use_subshell)
 534     {
 535         do_load_prompt ();
 536         if (new_dir_vpath != NULL)
 537             do_possible_cd (new_dir_vpath);
 538         if (mc_global.tty.console_flag != '\0' && output_lines)
 539             show_console_contents (output_start_y,
 540                                    LINES - mc_global.keybar_visible - output_lines -
 541                                    1, LINES - mc_global.keybar_visible - 1);
 542     }
 543
 544     vfs_path_free (new_dir_vpath);
 545 #endif /* ENABLE_SUBSHELL */
 546
 547     if (mc_global.mc_run_mode == MC_RUN_FULL)
 548     {
 549         update_panels (UP_OPTIMIZE, UP_KEEPSEL);
 550         update_xterm_title_path ();
 551     }
 552
 553     if (was_sigwinch != 0 || mc_global.tty.winch_flag != 0)
 554         dialog_change_screen_size ();
 555     else
 556         repaint_screen ();
 557 }
 558
 559 /* --------------------------------------------------------------------------------------------- */
 560
 561 /* event callback */
 562 gboolean
 563 execute_suspend (const gchar * event_group_name, const gchar * event_name,
 564                  gpointer init_data, gpointer data)
 565 {
 566     (void) event_group_name;
 567     (void) event_name;
 568     (void) init_data;
 569     (void) data;
 570
 571     if (mc_global.mc_run_mode == MC_RUN_FULL)
 572         save_cwds_stat ();
 573     do_suspend_cmd ();
 574     if (mc_global.mc_run_mode == MC_RUN_FULL)
 575         update_panels (UP_OPTIMIZE, UP_KEEPSEL);
 576     do_refresh ();
 577
 578     return TRUE;
 579 }
 580
 581 /* --------------------------------------------------------------------------------------------- */
 582
 583 /**
 584  * Execute command on a filename that can be on VFS.
 585  * Errors are reported to the user.
 586  */
 587
 588 void
 589 execute_with_vfs_arg (const char *command, const vfs_path_t * filename_vpath)
 590 {
 591     vfs_path_t *localcopy_vpath = NULL;
 592     const vfs_path_t *do_execute_vpath;
 593     time_t mtime;
 594
 595     if (!execute_prepare_with_vfs_arg (filename_vpath, &localcopy_vpath, &mtime))
 596         return;
 597
 598     do_execute_vpath = (localcopy_vpath == NULL) ? filename_vpath : localcopy_vpath;
 599
 600     do_execute (command, vfs_path_get_last_path_str (do_execute_vpath), EXECUTE_INTERNAL);
 601
 602     execute_cleanup_with_vfs_arg (filename_vpath, &localcopy_vpath, &mtime);
 603 }
 604
 605 /* --------------------------------------------------------------------------------------------- */
 606 /**
 607  * Execute external editor or viewer.
 608  *
 609  * @param command editor/viewer to run
 610  * @param filename_vpath path for edit/view
 611  * @param start_line cursor will be placed at the 'start_line' position after opening file
 612  */
 613
 614 void
 615 execute_external_editor_or_viewer (const char *command, const vfs_path_t * filename_vpath,
 616                                    long start_line)
 617 {
 618     vfs_path_t *localcopy_vpath = NULL;
 619     const vfs_path_t *do_execute_vpath;
 620     char *extern_cmd_options;
 621     time_t mtime;
 622
 623     if (!execute_prepare_with_vfs_arg (filename_vpath, &localcopy_vpath, &mtime))
 624         return;
 625
 626     do_execute_vpath = (localcopy_vpath == NULL) ? filename_vpath : localcopy_vpath;
 627
 628     extern_cmd_options =
 629         execute_get_external_cmd_opts_from_config (command, do_execute_vpath, start_line);
 630
 631     if (extern_cmd_options != NULL)
 632     {
 633         char **argv_cmd_options;
 634         int argv_count;
 635
 636         g_shell_parse_argv (extern_cmd_options, &argv_count, &argv_cmd_options, NULL);
 637         g_free (extern_cmd_options);
 638
 639         do_executev (command, EXECUTE_INTERNAL, argv_cmd_options);
 640
 641         g_strfreev (argv_cmd_options);
 642     }
 643
 644     execute_cleanup_with_vfs_arg (filename_vpath, &localcopy_vpath, &mtime);
 645 }
 646
 647 /* --------------------------------------------------------------------------------------------- */