src/filemanager/ext.c

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