src/ext.c

   1 /* Extension dependent execution.
   2    Copyright (C) 1994, 1995, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
   3    2005, 2007 Free Software Foundation, Inc.
   4
   5    Written by: 1995 Jakub Jelinek
   6    1994 Miguel de Icaza
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  21
  22 /** \file  ext.c
  23  *  \brief Source: extension dependent execution
  24  */
  25
  26 #include <config.h>
  27
  28 #include <ctype.h>
  29 #include <errno.h>
  30 #include <stdlib.h>
  31 #include <stdio.h>
  32 #include <string.h>
  33 #include <unistd.h>
  34
  35 #include "lib/global.h"
  36 #include "lib/tty/tty.h"
  37 #include "lib/search.h"
  38 #include "lib/fileloc.h"
  39 #include "lib/util.h"
  40 #include "lib/vfs/mc-vfs/vfs.h"
  41 #include "lib/widget.h"
  42 #include "lib/charsets.h"           /* get_codepage_index */
  43
  44 #include "consaver/cons.saver.h"
  45 #include "viewer/mcviewer.h"
  46
  47 #include "user.h"
  48 #include "main.h"
  49 #include "execute.h"
  50 #include "history.h"
  51 #include "layout.h"
  52 #ifdef HAVE_CHARSET
  53 #include "selcodepage.h"        /* do_set_codepage */
  54 #endif
  55 #include "ext.h"
  56
  57 /*** global variables ****************************************************************************/
  58
  59 /* If set, we execute the file command to check the file type */
  60 int use_file_to_check_type = 1;
  61
  62 /*** file scope macro definitions ****************************************************************/
  63
  64 #ifdef FILE_L
  65 #define FILE_CMD "file -L "
  66 #else
  67 #define FILE_CMD "file "
  68 #endif
  69
  70 /*** file scope type declarations ****************************************************************/
  71
  72 typedef char *(*quote_func_t) (const char *name, int quote_percent);
  73
  74 /*** file scope variables ************************************************************************/
  75
  76 /* This variable points to a copy of the mc.ext file in memory
  77  * With this we avoid loading/parsing the file each time we
  78  * need it
  79  */
  80 static char *data = NULL;
  81
  82 /*** file scope functions ************************************************************************/
  83 /* --------------------------------------------------------------------------------------------- */
  84
  85 static void
  86 exec_extension (const char *filename, const char *lc_data, int *move_dir, int start_line)
  87 {
  88     char *fn;
  89     char *file_name;
  90     int cmd_file_fd;
  91     FILE *cmd_file;
  92     char *cmd = NULL;
  93     int expand_prefix_found = 0;
  94     int parameter_found = 0;
  95     char lc_prompt[80];
  96     int run_view = 0;
  97     int def_hex_mode = mcview_default_hex_mode, changed_hex_mode = 0;
  98     int def_nroff_flag = mcview_default_nroff_flag, changed_nroff_flag = 0;
  99     int written_nonspace = 0;
 100     int is_cd = 0;
 101     char buffer[1024];
 102     char *p = 0;
 103     char *localcopy = NULL;
 104     int do_local_copy;
 105     time_t localmtime = 0;
 106     struct stat mystat;
 107     quote_func_t quote_func = name_quote;
 108
 109     g_return_if_fail (filename != NULL);
 110     g_return_if_fail (lc_data != NULL);
 111
 112     /* Avoid making a local copy if we are doing a cd */
 113     if (!vfs_file_is_local (filename))
 114         do_local_copy = 1;
 115     else
 116         do_local_copy = 0;
 117
 118     /*
 119      * All commands should be run in /bin/sh regardless of user shell.
 120      * To do that, create temporary shell script and run it.
 121      * Sometimes it's not needed (e.g. for %cd and %view commands),
 122      * but it's easier to create it anyway.
 123      */
 124     cmd_file_fd = mc_mkstemps (&file_name, "mcext", SCRIPT_SUFFIX);
 125
 126     if (cmd_file_fd == -1)
 127     {
 128         message (D_ERROR, MSG_ERROR,
 129                  _("Cannot create temporary command file\n%s"), unix_error_string (errno));
 130         return;
 131     }
 132
 133     cmd_file = fdopen (cmd_file_fd, "w");
 134     fputs ("#! /bin/sh\n", cmd_file);
 135
 136     lc_prompt[0] = '\0';
 137     for (; *lc_data != '\0' && *lc_data != '\n'; lc_data++)
 138     {
 139         if (parameter_found)
 140         {
 141             if (*lc_data == '}')
 142             {
 143                 char *parameter;
 144
 145                 parameter_found = 0;
 146                 parameter = input_dialog (_("Parameter"), lc_prompt, MC_HISTORY_EXT_PARAMETER, "");
 147                 if (parameter == NULL)
 148                 {
 149                     /* User canceled */
 150                     fclose (cmd_file);
 151                     unlink (file_name);
 152                     if (localcopy)
 153                     {
 154                         mc_ungetlocalcopy (filename, localcopy, 0);
 155                         g_free (localcopy);
 156                     }
 157                     g_free (file_name);
 158                     return;
 159                 }
 160                 fputs (parameter, cmd_file);
 161                 written_nonspace = 1;
 162                 g_free (parameter);
 163             }
 164             else
 165             {
 166                 size_t len = strlen (lc_prompt);
 167
 168                 if (len < sizeof (lc_prompt) - 1)
 169                 {
 170                     lc_prompt[len] = *lc_data;
 171                     lc_prompt[len + 1] = '\0';
 172                 }
 173             }
 174         }
 175         else if (expand_prefix_found)
 176         {
 177             expand_prefix_found = 0;
 178             if (*lc_data == '{')
 179                 parameter_found = 1;
 180             else
 181             {
 182                 int i;
 183                 char *v;
 184
 185                 i = check_format_view (lc_data);
 186                 if (i != 0)
 187                 {
 188                     lc_data += i - 1;
 189                     run_view = 1;
 190                 }
 191                 else
 192                 {
 193                     i = check_format_cd (lc_data);
 194                     if (i > 0)
 195                     {
 196                         is_cd = 1;
 197                         quote_func = fake_name_quote;
 198                         do_local_copy = 0;
 199                         p = buffer;
 200                         lc_data += i - 1;
 201                     }
 202                     else
 203                     {
 204                         i = check_format_var (lc_data, &v);
 205                         if (i > 0 && v != NULL)
 206                         {
 207                             fputs (v, cmd_file);
 208                             g_free (v);
 209                             lc_data += i;
 210                         }
 211                         else
 212                         {
 213                             char *text;
 214
 215                             if (*lc_data != 'f')
 216                                 text = expand_format (NULL, *lc_data, !is_cd);
 217                             else
 218                             {
 219                                 if (do_local_copy)
 220                                 {
 221                                     localcopy = mc_getlocalcopy (filename);
 222                                     if (localcopy == NULL)
 223                                     {
 224                                         fclose (cmd_file);
 225                                         unlink (file_name);
 226                                         g_free (file_name);
 227                                         return;
 228                                     }
 229                                     mc_stat (localcopy, &mystat);
 230                                     localmtime = mystat.st_mtime;
 231                                     text = quote_func (localcopy, 0);
 232                                 }
 233                                 else
 234                                 {
 235                                     fn = vfs_canon_and_translate (filename);
 236                                     text = quote_func (fn, 0);
 237                                     g_free (fn);
 238                                 }
 239                             }
 240
 241                             if (!is_cd)
 242                                 fputs (text, cmd_file);
 243                             else
 244                             {
 245                                 strcpy (p, text);
 246                                 p = strchr (p, 0);
 247                             }
 248
 249                             g_free (text);
 250                             written_nonspace = 1;
 251                         }
 252                     }
 253                 }
 254             }
 255         }
 256         else if (*lc_data == '%')
 257             expand_prefix_found = 1;
 258         else
 259         {
 260             if (*lc_data != ' ' && *lc_data != '\t')
 261                 written_nonspace = 1;
 262             if (is_cd)
 263                 *(p++) = *lc_data;
 264             else
 265                 fputc (*lc_data, cmd_file);
 266         }
 267     }                           /* for */
 268
 269     /*
 270      * Make the script remove itself when it finishes.
 271      * Don't do it for the viewer - it may need to rerun the script,
 272      * so we clean up after calling view().
 273      */
 274     if (!run_view)
 275         fprintf (cmd_file, "\n/bin/rm -f %s\n", file_name);
 276
 277     fclose (cmd_file);
 278
 279     if ((run_view && !written_nonspace) || is_cd)
 280     {
 281         unlink (file_name);
 282         g_free (file_name);
 283         file_name = NULL;
 284     }
 285     else
 286     {
 287         /* Set executable flag on the command file ... */
 288         chmod (file_name, S_IRWXU);
 289         /* ... but don't rely on it - run /bin/sh explicitly */
 290         cmd = g_strconcat ("/bin/sh ", file_name, (char *) NULL);
 291     }
 292
 293     if (run_view)
 294     {
 295         mcview_ret_t ret;
 296
 297         mcview_altered_hex_mode = 0;
 298         mcview_altered_nroff_flag = 0;
 299         if (def_hex_mode != mcview_default_hex_mode)
 300             changed_hex_mode = 1;
 301         if (def_nroff_flag != mcview_default_nroff_flag)
 302             changed_nroff_flag = 1;
 303
 304         /* If we've written whitespace only, then just load filename
 305          * into view
 306          */
 307         if (written_nonspace)
 308         {
 309             ret = mcview_viewer (cmd, filename, start_line);
 310             unlink (file_name);
 311         }
 312         else
 313             ret = mcview_viewer (NULL, filename, start_line);
 314
 315         if (move_dir != NULL)
 316             switch (ret)
 317             {
 318             case MCVIEW_WANT_NEXT:
 319                 *move_dir = 1;
 320                 break;
 321             case MCVIEW_WANT_PREV:
 322                 *move_dir = -1;
 323                 break;
 324             default:
 325                 *move_dir = 0;
 326             }
 327
 328         if (changed_hex_mode && !mcview_altered_hex_mode)
 329             mcview_default_hex_mode = def_hex_mode;
 330         if (changed_nroff_flag && !mcview_altered_nroff_flag)
 331             mcview_default_nroff_flag = def_nroff_flag;
 332
 333         dialog_switch_process_pending ();
 334     }
 335     else if (is_cd)
 336     {
 337         char *q;
 338         *p = 0;
 339         p = buffer;
 340         /*      while (*p == ' ' && *p == '\t')
 341          *          p++;
 342          */
 343         /* Search last non-space character. Start search at the end in order
 344            not to short filenames containing spaces. */
 345         q = p + strlen (p) - 1;
 346         while (q >= p && (*q == ' ' || *q == '\t'))
 347             q--;
 348         q[1] = 0;
 349         do_cd (p, cd_parse_command);
 350     }
 351     else
 352     {
 353         shell_execute (cmd, EXECUTE_INTERNAL);
 354         if (console_flag)
 355         {
 356             handle_console (CONSOLE_SAVE);
 357             if (output_lines && keybar_visible)
 358                 show_console_contents (output_start_y,
 359                                        LINES - keybar_visible -
 360                                        output_lines - 1, LINES - keybar_visible - 1);
 361         }
 362     }
 363
 364     g_free (file_name);
 365     g_free (cmd);
 366
 367     if (localcopy)
 368     {
 369         mc_stat (localcopy, &mystat);
 370         mc_ungetlocalcopy (filename, localcopy, localmtime != mystat.st_mtime);
 371         g_free (localcopy);
 372     }
 373 }
 374
 375 /* --------------------------------------------------------------------------------------------- */
 376 /**
 377  * Run cmd_file with args, put result into buf.
 378  * If error, put '\0' into buf[0]
 379  * Return 1 if the data is valid, 0 otherwise, -1 for fatal errors.
 380  *
 381  * NOTES: buf is null-terminated string.
 382  */
 383
 384 static int
 385 get_popen_information (const char *cmd_file, const char *args, char *buf, int buflen)
 386 {
 387     gboolean read_bytes = FALSE;
 388     char *command;
 389     FILE *f;
 390
 391     command = g_strconcat (cmd_file, args, " 2>/dev/null", (char *) NULL);
 392     f = popen (command, "r");
 393     g_free (command);
 394
 395     if (f != NULL)
 396     {
 397 #ifdef __QNXNTO__
 398         if (setvbuf (f, NULL, _IOFBF, 0) != 0)
 399         {
 400             (void) pclose (f);
 401             return -1;
 402         }
 403 #endif
 404         read_bytes = (fgets (buf, buflen, f) != NULL);
 405         if (!read_bytes)
 406             buf[0] = '\0';      /* Paranoid termination */
 407         pclose (f);
 408     }
 409     else
 410     {
 411         buf[0] = '\0';          /* Paranoid termination */
 412         return -1;
 413     }
 414
 415     buf[buflen - 1] = '\0';
 416
 417     return read_bytes ? 1 : 0;
 418 }
 419
 420 /* --------------------------------------------------------------------------------------------- */
 421 /**
 422  * Run the "file" command on the local file.
 423  * Return 1 if the data is valid, 0 otherwise, -1 for fatal errors.
 424  */
 425
 426 static int
 427 get_file_type_local (const char *filename, char *buf, int buflen)
 428 {
 429     char *tmp;
 430     int ret;
 431
 432     tmp = name_quote (filename, 0);
 433     ret = get_popen_information (FILE_CMD, tmp, buf, buflen);
 434     g_free (tmp);
 435
 436     return ret;
 437 }
 438
 439 /* --------------------------------------------------------------------------------------------- */
 440 /**
 441  * Run the "enca" command on the local file.
 442  * Return 1 if the data is valid, 0 otherwise, -1 for fatal errors.
 443  */
 444
 445 #ifdef HAVE_CHARSET
 446 static int
 447 get_file_encoding_local (const char *filename, char *buf, int buflen)
 448 {
 449     char *tmp, *lang, *args;
 450     int ret;
 451
 452     tmp = name_quote (filename, 0);
 453     lang = name_quote (autodetect_codeset, 0);
 454     args = g_strconcat (" -L", lang, " -i ", tmp, (char *) NULL);
 455
 456     ret = get_popen_information ("enca", args, buf, buflen);
 457
 458     g_free (args);
 459     g_free (lang);
 460     g_free (tmp);
 461
 462     return ret;
 463 }
 464 #endif /* HAVE_CHARSET */
 465
 466 /* --------------------------------------------------------------------------------------------- */
 467 /**
 468  * Invoke the "file" command on the file and match its output against PTR.
 469  * have_type is a flag that is set if we already have tried to determine
 470  * the type of that file.
 471  * Return 1 for match, 0 for no match, -1 errors.
 472  */
 473
 474 static int
 475 regex_check_type (const char *filename, const char *ptr, int *have_type)
 476 {
 477     int found = 0;
 478
 479     /* Following variables are valid if *have_type is 1 */
 480     static char content_string[2048];
 481     static char encoding_id[21];        /* CSISO51INISCYRILLIC -- 20 */
 482     static size_t content_shift = 0;
 483     static int got_data = 0;
 484
 485     if (!use_file_to_check_type)
 486         return 0;
 487
 488     if (*have_type == 0)
 489     {
 490         char *realname;         /* name used with "file" */
 491         char *localfile;
 492
 493 #ifdef HAVE_CHARSET
 494         int got_encoding_data;
 495 #endif /* HAVE_CHARSET */
 496
 497         /* Don't repeate even unsuccessful checks */
 498         *have_type = 1;
 499
 500         localfile = mc_getlocalcopy (filename);
 501         if (localfile == NULL)
 502             return -1;
 503
 504         realname = localfile;
 505
 506 #ifdef HAVE_CHARSET
 507         got_encoding_data = is_autodetect_codeset_enabled
 508             ? get_file_encoding_local (localfile, encoding_id, sizeof (encoding_id)) : 0;
 509
 510         if (got_encoding_data > 0)
 511         {
 512             char *pp;
 513             int cp_id;
 514
 515             pp = strchr (encoding_id, '\n');
 516             if (pp != NULL)
 517                 *pp = '\0';
 518
 519             cp_id = get_codepage_index (encoding_id);
 520             if (cp_id == -1)
 521                 cp_id = default_source_codepage;
 522
 523             do_set_codepage (cp_id);
 524         }
 525 #endif /* HAVE_CHARSET */
 526
 527         mc_ungetlocalcopy (filename, localfile, 0);
 528
 529         got_data = get_file_type_local (localfile, content_string, sizeof (content_string));
 530
 531         if (got_data > 0)
 532         {
 533             char *pp;
 534             size_t real_len;
 535
 536             pp = strchr (content_string, '\n');
 537             if (pp != NULL)
 538                 *pp = '\0';
 539
 540             real_len = strlen (realname);
 541
 542             if (strncmp (content_string, realname, real_len) == 0)
 543             {
 544                 /* Skip "realname: " */
 545                 content_shift = real_len;
 546                 if (content_string[content_shift] == ':')
 547                 {
 548                     /* Solaris' file prints tab(s) after ':' */
 549                     for (content_shift++;
 550                          content_string[content_shift] == ' '
 551                          || content_string[content_shift] == '\t'; content_shift++)
 552                         ;
 553                 }
 554             }
 555         }
 556         else
 557         {
 558             /* No data */
 559             content_string[0] = '\0';
 560         }
 561         g_free (realname);
 562     }
 563
 564     if (got_data == -1)
 565         return -1;
 566
 567     if (content_string[0] != '\0'
 568         && mc_search (ptr, content_string + content_shift, MC_SEARCH_T_REGEX))
 569     {
 570         found = 1;
 571     }
 572
 573     return found;
 574 }
 575
 576 /* --------------------------------------------------------------------------------------------- */
 577 /*** public functions ****************************************************************************/
 578 /* --------------------------------------------------------------------------------------------- */
 579
 580 void
 581 flush_extension_file (void)
 582 {
 583     g_free (data);
 584     data = NULL;
 585 }
 586
 587 /* --------------------------------------------------------------------------------------------- */
 588 /**
 589  * The second argument is action, i.e. Open, View or Edit
 590  *
 591  * This function returns:
 592  *
 593  * -1 for a failure or user interrupt
 594  * 0 if no command was run
 595  * 1 if some command was run
 596  *
 597  * If action == "View" then a parameter is checked in the form of "View:%d",
 598  * if the value for %d exists, then the viewer is started up at that line number.
 599  */
 600
 601 int
 602 regex_command (const char *filename, const char *action, int *move_dir)
 603 {
 604     char *p, *q, *r, c;
 605     int file_len = strlen (filename);
 606     int found = 0;
 607     int error_flag = 0;
 608     int ret = 0;
 609     struct stat mystat;
 610     int view_at_line_number;
 611     char *include_target;
 612     int include_target_len;
 613     int have_type = 0;          /* Flag used by regex_check_type() */
 614
 615     /* Check for the special View:%d parameter */
 616     if (strncmp (action, "View:", 5) == 0)
 617     {
 618         view_at_line_number = atoi (action + 5);
 619         action = "View";
 620     }
 621     else
 622     {
 623         view_at_line_number = 0;
 624     }
 625
 626     if (data == NULL)
 627     {
 628         char *extension_file;
 629         int mc_user_ext = 1;
 630         int home_error = 0;
 631
 632         extension_file = g_build_filename (home_dir, MC_USERCONF_DIR, MC_FILEBIND_FILE, NULL);
 633         if (!exist_file (extension_file))
 634         {
 635             g_free (extension_file);
 636           check_stock_mc_ext:
 637             extension_file = concat_dir_and_file (mc_home, MC_LIB_EXT);
 638             if (!exist_file (extension_file))
 639             {
 640                 g_free (extension_file);
 641                 extension_file = concat_dir_and_file (mc_home_alt, MC_LIB_EXT);
 642             }
 643             mc_user_ext = 0;
 644         }
 645
 646         g_file_get_contents (extension_file, &data, NULL, NULL);
 647         g_free (extension_file);
 648         if (data == NULL)
 649             return 0;
 650
 651         if (!strstr (data, "default/"))
 652         {
 653             if (!strstr (data, "regex/") && !strstr (data, "shell/") && !strstr (data, "type/"))
 654             {
 655                 g_free (data);
 656                 data = NULL;
 657                 if (mc_user_ext)
 658                 {
 659                     home_error = 1;
 660                     goto check_stock_mc_ext;
 661                 }
 662                 else
 663                 {
 664                     char *title = g_strdup_printf (_(" %s%s file error"),
 665                                                    mc_home, MC_LIB_EXT);
 666                     message (D_ERROR, title, _("The format of the %smc.ext "
 667                                                "file has changed with version 3.0. It seems that "
 668                                                "the installation failed. Please fetch a fresh "
 669                                                "copy from the Midnight Commander package."),
 670                              mc_home);
 671                     g_free (title);
 672                     return 0;
 673                 }
 674             }
 675         }
 676         if (home_error)
 677         {
 678             char *title = g_strdup_printf (_("~/%s file error"),
 679                                            MC_USERCONF_DIR PATH_SEP_STR MC_FILEBIND_FILE);
 680             message (D_ERROR, title,
 681                      _("The format of the ~/%s file has "
 682                        "changed with version 3.0. You may either want to copy "
 683                        "it from %smc.ext or use that file as an example of how to write it."),
 684                      MC_USERCONF_DIR PATH_SEP_STR MC_FILEBIND_FILE, mc_home);
 685             g_free (title);
 686         }
 687     }
 688     mc_stat (filename, &mystat);
 689
 690     include_target = NULL;
 691     include_target_len = 0;
 692     for (p = data; *p; p++)
 693     {
 694         for (q = p; *q == ' ' || *q == '\t'; q++);
 695         if (*q == '\n' || !*q)
 696             p = q;              /* empty line */
 697         if (*p == '#')          /* comment */
 698             while (*p && *p != '\n')
 699                 p++;
 700         if (*p == '\n')
 701             continue;
 702         if (!*p)
 703             break;
 704         if (p == q)
 705         {                       /* i.e. starts in the first column, should be
 706                                  * keyword/descNL
 707                                  */
 708             found = 0;
 709             q = strchr (p, '\n');
 710             if (q == NULL)
 711                 q = strchr (p, 0);
 712             c = *q;
 713             *q = 0;
 714             if (include_target)
 715             {
 716                 if ((strncmp (p, "include/", 8) == 0)
 717                     && (strncmp (p + 8, include_target, include_target_len) == 0))
 718                     found = 1;
 719             }
 720             else if (!strncmp (p, "regex/", 6))
 721             {
 722                 p += 6;
 723                 /* Do not transform shell patterns, you can use shell/ for
 724                  * that
 725                  */
 726                 if (mc_search (p, filename, MC_SEARCH_T_REGEX))
 727                     found = 1;
 728             }
 729             else if (!strncmp (p, "directory/", 10))
 730             {
 731                 if (S_ISDIR (mystat.st_mode) && mc_search (p + 10, filename, MC_SEARCH_T_REGEX))
 732                     found = 1;
 733             }
 734             else if (!strncmp (p, "shell/", 6))
 735             {
 736                 p += 6;
 737                 if (*p == '.' && file_len >= (q - p))
 738                 {
 739                     if (!strncmp (p, filename + file_len - (q - p), q - p))
 740                         found = 1;
 741                 }
 742                 else
 743                 {
 744                     if (q - p == file_len && !strncmp (p, filename, q - p))
 745                         found = 1;
 746                 }
 747             }
 748             else if (!strncmp (p, "type/", 5))
 749             {
 750                 int res;
 751                 p += 5;
 752                 res = regex_check_type (filename, p, &have_type);
 753                 if (res == 1)
 754                     found = 1;
 755                 if (res == -1)
 756                     error_flag = 1;     /* leave it if file cannot be opened */
 757             }
 758             else if (!strncmp (p, "default/", 8))
 759             {
 760                 found = 1;
 761             }
 762             *q = c;
 763             p = q;
 764             if (!*p)
 765                 break;
 766         }
 767         else
 768         {                       /* List of actions */
 769             p = q;
 770             q = strchr (p, '\n');
 771             if (q == NULL)
 772                 q = strchr (p, 0);
 773             if (found && !error_flag)
 774             {
 775                 r = strchr (p, '=');
 776                 if (r != NULL)
 777                 {
 778                     c = *r;
 779                     *r = 0;
 780                     if (strcmp (p, "Include") == 0)
 781                     {
 782                         char *t;
 783
 784                         include_target = p + 8;
 785                         t = strchr (include_target, '\n');
 786                         if (t)
 787                             *t = 0;
 788                         include_target_len = strlen (include_target);
 789                         if (t)
 790                             *t = '\n';
 791
 792                         *r = c;
 793                         p = q;
 794                         found = 0;
 795
 796                         if (!*p)
 797                             break;
 798                         continue;
 799                     }
 800                     if (!strcmp (action, p))
 801                     {
 802                         *r = c;
 803                         for (p = r + 1; *p == ' ' || *p == '\t'; p++);
 804
 805                         /* Empty commands just stop searching
 806                          * through, they don't do anything
 807                          *
 808                          * We need to copy the filename because exec_extension
 809                          * may end up invoking update_panels thus making the
 810                          * filename parameter invalid (ie, most of the time,
 811                          * we get filename as a pointer from current_panel->dir).
 812                          */
 813                         if (p < q)
 814                         {
 815                             char *filename_copy = g_strdup (filename);
 816
 817                             exec_extension (filename_copy, r + 1, move_dir, view_at_line_number);
 818                             g_free (filename_copy);
 819
 820                             ret = 1;
 821                         }
 822                         break;
 823                     }
 824                     else
 825                         *r = c;
 826                 }
 827             }
 828             p = q;
 829             if (!*p)
 830                 break;
 831         }
 832     }
 833     if (error_flag)
 834         return -1;
 835     return ret;
 836 }
 837
 838 /* --------------------------------------------------------------------------------------------- */