This source file includes following definitions.
- exec_cleanup_script
- exec_cleanup_file_name
- exec_get_file_name
- exec_expand_format
- exec_get_export_variables
- exec_make_shell_string
- exec_extension_view
- exec_extension_cd
- exec_extension
- get_popen_information
- get_file_type_local
- get_file_encoding_local
- regex_check_type
- check_old_extension_file
- load_extension_file
- flush_extension_file
- regex_command_for
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32 #include <config.h>
33
34 #include <ctype.h>
35 #include <stdlib.h>
36 #include <stdio.h>
37 #include <string.h>
38 #include <unistd.h>
39
40 #include "lib/global.h"
41 #include "lib/tty/tty.h"
42 #include "lib/search.h"
43 #include "lib/fileloc.h"
44 #include "lib/mcconfig.h"
45 #include "lib/util.h"
46 #include "lib/vfs/vfs.h"
47 #include "lib/widget.h"
48 #include "lib/charsets.h"
49
50 #ifdef USE_FILE_CMD
51 #include "src/setup.h"
52 #endif
53 #include "src/execute.h"
54 #include "src/history.h"
55 #include "src/usermenu.h"
56
57 #include "src/consaver/cons.saver.h"
58 #include "src/viewer/mcviewer.h"
59 #include "src/selcodepage.h"
60 #include "src/util.h"
61
62 #include "filemanager.h"
63 #include "panel.h"
64
65 #include "ext.h"
66
67
68
69
70
71 #ifdef USE_FILE_CMD
72 #ifdef FILE_B
73 #define FILE_CMD "file -z " FILE_B FILE_S FILE_L
74 #else
75 #define FILE_CMD "file -z " FILE_S FILE_L
76 #endif
77 #endif
78
79
80
81 typedef char *(*quote_func_t) (const char *name, gboolean quote_percent);
82
83
84
85
86
87
88
89
90
91 static mc_config_t *ext_ini = NULL;
92 static gchar **ext_ini_groups = NULL;
93 static vfs_path_t *localfilecopy_vpath = NULL;
94 static char buffer[BUF_1K];
95
96 static char *pbuffer = NULL;
97 static time_t localmtime = 0;
98 static quote_func_t quote_func = name_quote;
99 static gboolean run_view = FALSE;
100 static gboolean is_cd = FALSE;
101 static gboolean written_nonspace = FALSE;
102 static gboolean do_local_copy = FALSE;
103
104 static const char *descr_group = "mc.ext.ini";
105 static const char *default_group = "Default";
106
107
108
109
110
111 static void
112 exec_cleanup_script (vfs_path_t *script_vpath)
113 {
114 if (script_vpath != NULL)
115 {
116 (void) mc_unlink (script_vpath);
117 vfs_path_free (script_vpath, TRUE);
118 }
119 }
120
121
122
123 static void
124 exec_cleanup_file_name (const vfs_path_t *filename_vpath, gboolean has_changed)
125 {
126 if (localfilecopy_vpath == NULL)
127 return;
128
129 if (has_changed)
130 {
131 struct stat mystat;
132
133 mc_stat (localfilecopy_vpath, &mystat);
134 has_changed = localmtime != mystat.st_mtime;
135 }
136 mc_ungetlocalcopy (filename_vpath, localfilecopy_vpath, has_changed);
137 vfs_path_free (localfilecopy_vpath, TRUE);
138 localfilecopy_vpath = NULL;
139 }
140
141
142
143 static char *
144 exec_get_file_name (const vfs_path_t *filename_vpath)
145 {
146 if (!do_local_copy)
147 return quote_func (vfs_path_get_last_path_str (filename_vpath), FALSE);
148
149 if (localfilecopy_vpath == NULL)
150 {
151 struct stat mystat;
152 localfilecopy_vpath = mc_getlocalcopy (filename_vpath);
153 if (localfilecopy_vpath == NULL)
154 return NULL;
155
156 mc_stat (localfilecopy_vpath, &mystat);
157 localmtime = mystat.st_mtime;
158 }
159
160 return quote_func (vfs_path_get_last_path_str (localfilecopy_vpath), FALSE);
161 }
162
163
164
165 static char *
166 exec_expand_format (char symbol, gboolean is_result_quoted)
167 {
168 char *text;
169
170 text = expand_format (NULL, symbol, TRUE);
171 if (is_result_quoted && text != NULL)
172 {
173 char *quoted_text;
174
175 quoted_text = g_strdup_printf ("\"%s\"", text);
176 g_free (text);
177 text = quoted_text;
178 }
179 return text;
180 }
181
182
183
184 static GString *
185 exec_get_export_variables (const vfs_path_t *filename_vpath)
186 {
187 char *text;
188 GString *export_vars_string;
189 size_t i;
190
191 struct
192 {
193 const char symbol;
194 const char *name;
195 const gboolean is_result_quoted;
196 } export_variables[] = {
197 { 'p', "MC_EXT_BASENAME", FALSE },
198 { 'd', "MC_EXT_CURRENTDIR", FALSE },
199 { 's', "MC_EXT_SELECTED", TRUE },
200 { 't', "MC_EXT_ONLYTAGGED", TRUE },
201 { '\0', NULL, FALSE },
202 };
203
204 text = exec_get_file_name (filename_vpath);
205 if (text == NULL)
206 return NULL;
207
208 export_vars_string = g_string_new ("MC_EXT_FILENAME=");
209 g_string_append_printf (export_vars_string, "%s\nexport MC_EXT_FILENAME\n", text);
210 g_free (text);
211
212 for (i = 0; export_variables[i].name != NULL; i++)
213 {
214 text =
215 exec_expand_format (export_variables[i].symbol, export_variables[i].is_result_quoted);
216 if (text != NULL)
217 {
218 g_string_append_printf (export_vars_string, "%s=%s\nexport %s\n",
219 export_variables[i].name, text, export_variables[i].name);
220 g_free (text);
221 }
222 }
223
224 return export_vars_string;
225 }
226
227
228
229 static GString *
230 exec_make_shell_string (const char *lc_data, const vfs_path_t *filename_vpath)
231 {
232 GString *shell_string;
233 char lc_prompt[80] = "\0";
234 gboolean parameter_found = FALSE;
235 gboolean expand_prefix_found = FALSE;
236
237 shell_string = g_string_new ("");
238
239 for (; *lc_data != '\0' && *lc_data != '\n'; lc_data++)
240 {
241 if (parameter_found)
242 {
243 if (*lc_data == '}')
244 {
245 char *parameter;
246
247 parameter_found = FALSE;
248 parameter = input_dialog (_ ("Parameter"), lc_prompt, MC_HISTORY_EXT_PARAMETER, "",
249 INPUT_COMPLETE_NONE);
250 if (parameter == NULL)
251 {
252
253 g_string_free (shell_string, TRUE);
254 exec_cleanup_file_name (filename_vpath, FALSE);
255 return NULL;
256 }
257 g_string_append (shell_string, parameter);
258 written_nonspace = TRUE;
259 g_free (parameter);
260 }
261 else
262 {
263 size_t len = strlen (lc_prompt);
264
265 if (len < sizeof (lc_prompt) - 1)
266 {
267 lc_prompt[len] = *lc_data;
268 lc_prompt[len + 1] = '\0';
269 }
270 }
271 }
272 else if (expand_prefix_found)
273 {
274 expand_prefix_found = FALSE;
275 if (*lc_data == '{')
276 parameter_found = TRUE;
277 else
278 {
279 int i;
280
281 i = check_format_view (lc_data);
282 if (i != 0)
283 {
284 lc_data += i - 1;
285 run_view = TRUE;
286 }
287 else
288 {
289 i = check_format_cd (lc_data);
290 if (i > 0)
291 {
292 is_cd = TRUE;
293 quote_func = fake_name_quote;
294 do_local_copy = FALSE;
295 pbuffer = buffer;
296 lc_data += i - 1;
297 }
298 else
299 {
300 char *v;
301
302 i = check_format_var (lc_data, &v);
303 if (i > 0)
304 {
305 g_string_append (shell_string, v);
306 g_free (v);
307 lc_data += i;
308 }
309 else
310 {
311 char *text;
312
313 if (*lc_data != 'f')
314 text = expand_format (NULL, *lc_data, !is_cd);
315 else
316 {
317 text = exec_get_file_name (filename_vpath);
318 if (text == NULL)
319 {
320 g_string_free (shell_string, TRUE);
321 return NULL;
322 }
323 }
324
325 if (text != NULL)
326 {
327 if (!is_cd)
328 g_string_append (shell_string, text);
329 else
330 {
331 strcpy (pbuffer, text);
332 pbuffer = strchr (pbuffer, '\0');
333 }
334
335 g_free (text);
336 }
337
338 written_nonspace = TRUE;
339 }
340 }
341 }
342 }
343 }
344 else if (*lc_data == '%')
345 expand_prefix_found = TRUE;
346 else
347 {
348 if (!whitespace (*lc_data))
349 written_nonspace = TRUE;
350 if (is_cd)
351 *(pbuffer++) = *lc_data;
352 else
353 g_string_append_c (shell_string, *lc_data);
354 }
355 }
356
357 return shell_string;
358 }
359
360
361
362 static void
363 exec_extension_view (void *target, char *cmd, const vfs_path_t *filename_vpath, int start_line)
364 {
365 mcview_mode_flags_t def_flags = {
366 .wrap = FALSE,
367 .hex = mcview_global_flags.hex,
368 .magic = FALSE,
369 .nroff = mcview_global_flags.nroff,
370 };
371
372 mcview_mode_flags_t changed_flags;
373
374 mcview_clear_mode_flags (&changed_flags);
375 mcview_altered_flags.hex = FALSE;
376 mcview_altered_flags.nroff = FALSE;
377 if (def_flags.hex != mcview_global_flags.hex)
378 changed_flags.hex = TRUE;
379 if (def_flags.nroff != mcview_global_flags.nroff)
380 changed_flags.nroff = TRUE;
381
382 if (target == NULL)
383 mcview_viewer (cmd, filename_vpath, start_line, 0, 0);
384 else
385 mcview_load ((WView *) target, cmd, vfs_path_as_str (filename_vpath), start_line, 0, 0);
386
387 if (changed_flags.hex && !mcview_altered_flags.hex)
388 mcview_global_flags.hex = def_flags.hex;
389 if (changed_flags.nroff && !mcview_altered_flags.nroff)
390 mcview_global_flags.nroff = def_flags.nroff;
391
392 dialog_switch_process_pending ();
393 }
394
395
396
397 static void
398 exec_extension_cd (WPanel *panel)
399 {
400 char *q;
401 vfs_path_t *p_vpath;
402
403 *pbuffer = '\0';
404 pbuffer = buffer;
405
406
407 q = pbuffer + strlen (pbuffer) - 1;
408 while (q >= pbuffer && whitespace (*q))
409 q--;
410 q[1] = 0;
411
412 p_vpath = vfs_path_from_str_flags (pbuffer, VPF_NO_CANON);
413 panel_cd (panel, p_vpath, cd_parse_command);
414 vfs_path_free (p_vpath, TRUE);
415 }
416
417
418
419 static vfs_path_t *
420 exec_extension (WPanel *panel, void *target, const vfs_path_t *filename_vpath, const char *lc_data,
421 int start_line)
422 {
423 GString *shell_string, *export_variables;
424 vfs_path_t *script_vpath = NULL;
425 int cmd_file_fd;
426 FILE *cmd_file;
427 char *cmd = NULL;
428
429 pbuffer = NULL;
430 localmtime = 0;
431 quote_func = name_quote;
432 run_view = FALSE;
433 is_cd = FALSE;
434 written_nonspace = FALSE;
435
436
437 do_local_copy = !vfs_file_is_local (filename_vpath);
438
439 shell_string = exec_make_shell_string (lc_data, filename_vpath);
440 if (shell_string == NULL)
441 goto ret;
442
443 if (is_cd)
444 {
445 exec_extension_cd (panel);
446 g_string_free (shell_string, TRUE);
447 goto ret;
448 }
449
450
451
452
453
454
455
456 cmd_file_fd = mc_mkstemps (&script_vpath, "mcext", SCRIPT_SUFFIX);
457
458 if (cmd_file_fd == -1)
459 {
460 file_error_message (_ ("Cannot create temporary command file"), NULL);
461 g_string_free (shell_string, TRUE);
462 goto ret;
463 }
464
465 cmd_file = fdopen (cmd_file_fd, "w");
466 fputs ("#! /bin/sh\n\n", cmd_file);
467
468 export_variables = exec_get_export_variables (filename_vpath);
469 if (export_variables != NULL)
470 {
471 fputs (export_variables->str, cmd_file);
472 g_string_free (export_variables, TRUE);
473 }
474
475 fputs (shell_string->str, cmd_file);
476 g_string_free (shell_string, TRUE);
477
478
479
480
481
482
483 if (!run_view)
484 fprintf (cmd_file, "\n/bin/rm -f %s\n", vfs_path_as_str (script_vpath));
485
486 fclose (cmd_file);
487
488 if ((run_view && !written_nonspace) || is_cd)
489 {
490 exec_cleanup_script (script_vpath);
491 script_vpath = NULL;
492 }
493 else
494 {
495
496 mc_chmod (script_vpath, S_IRWXU);
497
498 cmd = g_strconcat ("/bin/sh ", vfs_path_as_str (script_vpath), (char *) NULL);
499 }
500
501 if (run_view)
502 {
503
504 if (!written_nonspace)
505 exec_extension_view (target, NULL, filename_vpath, start_line);
506 else
507 exec_extension_view (target, cmd, filename_vpath, start_line);
508 }
509 else
510 {
511 shell_execute (cmd, EXECUTE_INTERNAL);
512 if (mc_global.tty.console_flag != '\0')
513 {
514 handle_console (CONSOLE_SAVE);
515 if (output_lines != 0 && mc_global.keybar_visible)
516 {
517 unsigned char end_line;
518
519 end_line = LINES - (mc_global.keybar_visible ? 1 : 0) - 1;
520 show_console_contents (output_start_y, end_line - output_lines, end_line);
521 }
522 }
523 }
524
525 g_free (cmd);
526
527 exec_cleanup_file_name (filename_vpath, TRUE);
528 ret:
529 return script_vpath;
530 }
531
532
533
534
535
536
537
538
539
540
541 #ifdef USE_FILE_CMD
542 static int
543 get_popen_information (const char *cmd_file, const char *args, char *buf, int buflen)
544 {
545 gboolean read_bytes = FALSE;
546 char *command;
547 FILE *f;
548
549 command = g_strconcat (cmd_file, args, " 2>/dev/null", (char *) NULL);
550 f = popen (command, "r");
551 g_free (command);
552
553 if (f != NULL)
554 {
555 #ifdef __QNXNTO__
556 if (setvbuf (f, NULL, _IOFBF, 0) != 0)
557 {
558 (void) pclose (f);
559 return -1;
560 }
561 #endif
562 read_bytes = (fgets (buf, buflen, f) != NULL);
563 if (!read_bytes)
564 buf[0] = '\0';
565 pclose (f);
566 }
567 else
568 {
569 buf[0] = '\0';
570 return -1;
571 }
572
573 buf[buflen - 1] = '\0';
574
575 return read_bytes ? 1 : 0;
576 }
577
578
579
580
581
582
583
584 static int
585 get_file_type_local (const vfs_path_t *filename_vpath, char *buf, int buflen)
586 {
587 char *filename_quoted;
588 int ret = 0;
589
590 filename_quoted = name_quote (vfs_path_get_last_path_str (filename_vpath), FALSE);
591 if (filename_quoted != NULL)
592 {
593 ret = get_popen_information (FILE_CMD, filename_quoted, buf, buflen);
594 g_free (filename_quoted);
595 }
596
597 return ret;
598 }
599
600
601
602
603
604
605
606 static int
607 get_file_encoding_local (const vfs_path_t *filename_vpath, char *buf, int buflen)
608 {
609 char *filename_quoted;
610 int ret = 0;
611
612 filename_quoted = name_quote (vfs_path_get_last_path_str (filename_vpath), FALSE);
613 if (filename_quoted != NULL)
614 {
615 char *lang;
616
617 lang = name_quote (autodetect_codeset, FALSE);
618 if (lang != NULL)
619 {
620 char *args;
621
622 args = g_strdup_printf (" -L %s -i %s", lang, filename_quoted);
623 g_free (lang);
624
625 ret = get_popen_information ("enca", args, buf, buflen);
626 g_free (args);
627 }
628
629 g_free (filename_quoted);
630 }
631
632 return ret;
633 }
634
635
636
637
638
639
640
641
642
643 static gboolean
644 regex_check_type (const vfs_path_t *filename_vpath, const char *ptr, gboolean case_insense,
645 gboolean *have_type, GError **mcerror)
646 {
647 gboolean found = FALSE;
648
649
650 static char content_string[BUF_2K];
651 static size_t content_shift = 0;
652 static int got_data = 0;
653
654 mc_return_val_if_error (mcerror, FALSE);
655
656 if (!*have_type)
657 {
658 vfs_path_t *localfile_vpath;
659
660 static char encoding_id[21];
661 int got_encoding_data;
662
663
664 *have_type = TRUE;
665
666 localfile_vpath = mc_getlocalcopy (filename_vpath);
667 if (localfile_vpath == NULL)
668 {
669 mc_propagate_error (mcerror, 0, _ ("Cannot fetch a local copy of %s"),
670 vfs_path_as_str (filename_vpath));
671 return FALSE;
672 }
673
674 got_encoding_data = is_autodetect_codeset_enabled
675 ? get_file_encoding_local (localfile_vpath, encoding_id, sizeof (encoding_id))
676 : 0;
677
678 if (got_encoding_data > 0)
679 {
680 char *pp;
681 int cp_id;
682
683 pp = strchr (encoding_id, '\n');
684 if (pp != NULL)
685 *pp = '\0';
686
687 cp_id = get_codepage_index (encoding_id);
688 if (cp_id == -1)
689 cp_id = default_source_codepage;
690
691 do_set_codepage (cp_id);
692 }
693
694 got_data = get_file_type_local (localfile_vpath, content_string, sizeof (content_string));
695
696 mc_ungetlocalcopy (filename_vpath, localfile_vpath, FALSE);
697
698 if (got_data > 0)
699 {
700 char *pp;
701
702 pp = strchr (content_string, '\n');
703 if (pp != NULL)
704 *pp = '\0';
705
706 #ifndef FILE_B
707 {
708 const char *real_name;
709 size_t real_len;
710
711 real_name = vfs_path_get_last_path_str (localfile_vpath);
712 real_len = strlen (real_name);
713
714 if (strncmp (content_string, real_name, real_len) == 0)
715 {
716
717 content_shift = real_len;
718
719
720 if (content_string[content_shift] == ':')
721 for (content_shift++; whitespace (content_string[content_shift]);
722 content_shift++)
723 ;
724 }
725 }
726 #endif
727 }
728 else
729 {
730
731 content_string[0] = '\0';
732 }
733 vfs_path_free (localfile_vpath, TRUE);
734 }
735
736 if (got_data == -1)
737 {
738 mc_propagate_error (mcerror, 0, "%s", _ ("Pipe failed"));
739 return FALSE;
740 }
741
742 if (content_string[0] != '\0')
743 {
744 mc_search_t *search;
745
746 search = mc_search_new (ptr, NULL);
747 if (search != NULL)
748 {
749 search->search_type = MC_SEARCH_T_REGEX;
750 search->is_case_sensitive = !case_insense;
751 found = mc_search_run (search, content_string + content_shift, 0,
752 sizeof (content_string) - 1, NULL);
753 mc_search_free (search);
754 }
755 else
756 {
757 mc_propagate_error (mcerror, 0, "%s", _ ("Regular expression error"));
758 }
759 }
760
761 return found;
762 }
763 #endif
764
765
766
767 static void
768 check_old_extension_file (void)
769 {
770 char *extension_old_file;
771
772 extension_old_file = mc_config_get_full_path (MC_EXT_OLD_FILE);
773 if (exist_file (extension_old_file))
774 message (D_ERROR, _ ("Warning"),
775 _ ("You have an outdated %s file.\n%s now uses %s file.\n"
776 "Please copy your modifications of the old file to the new one."),
777 extension_old_file, PACKAGE_NAME, MC_EXT_FILE);
778 g_free (extension_old_file);
779 }
780
781
782
783 static gboolean
784 load_extension_file (void)
785 {
786 char *extension_file;
787 gboolean mc_user_ext = TRUE;
788 gboolean home_error = FALSE;
789
790 extension_file = mc_config_get_full_path (MC_EXT_FILE);
791 if (!exist_file (extension_file))
792 {
793 g_free (extension_file);
794
795 check_old_extension_file ();
796
797 check_stock_mc_ext:
798 extension_file = mc_build_filename (mc_global.sysconfig_dir, MC_EXT_FILE, (char *) NULL);
799 if (!exist_file (extension_file))
800 {
801 g_free (extension_file);
802 extension_file =
803 mc_build_filename (mc_global.share_data_dir, MC_EXT_FILE, (char *) NULL);
804 if (!exist_file (extension_file))
805 MC_PTR_FREE (extension_file);
806 }
807 mc_user_ext = FALSE;
808 }
809
810 if (extension_file != NULL)
811 {
812 ext_ini = mc_config_init (extension_file, TRUE);
813 g_free (extension_file);
814 }
815 if (ext_ini == NULL)
816 return FALSE;
817
818
819 if (!mc_config_has_group (ext_ini, descr_group))
820 {
821 flush_extension_file ();
822
823 if (!mc_user_ext)
824 {
825 message (D_ERROR, MSG_ERROR,
826 _ ("The format of the\n%s%s\nfile has changed with version 4.0.\n"
827 "It seems that the installation has failed.\nPlease fetch a fresh copy "
828 "from the %s package."),
829 mc_global.sysconfig_dir, MC_EXT_FILE, PACKAGE_NAME);
830 return FALSE;
831 }
832
833 home_error = TRUE;
834 goto check_stock_mc_ext;
835 }
836
837 if (home_error)
838 {
839 extension_file = mc_config_get_full_path (MC_EXT_FILE);
840 message (
841 D_ERROR, MSG_ERROR,
842 _ ("The format of the\n%s\nfile has changed with version 4.0.\nYou may either want "
843 "to copy it from\n%s%s\nor use that file as an example of how to write it."),
844 extension_file, mc_global.sysconfig_dir, MC_EXT_FILE);
845 g_free (extension_file);
846 }
847
848 return TRUE;
849 }
850
851
852
853
854
855 void
856 flush_extension_file (void)
857 {
858 g_strfreev (ext_ini_groups);
859 ext_ini_groups = NULL;
860
861 mc_config_deinit (ext_ini);
862 ext_ini = NULL;
863 }
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880 int
881 regex_command_for (void *target, const vfs_path_t *filename_vpath, const char *action,
882 vfs_path_t **script_vpath)
883 {
884 const char *filename;
885 size_t filename_len;
886 gboolean found = FALSE;
887 gboolean error_flag = FALSE;
888 int ret = 0;
889 struct stat mystat;
890 int view_at_line_number = 0;
891 #ifdef USE_FILE_CMD
892 gboolean have_type = FALSE;
893 #endif
894 char **group_iter;
895 char *include_group = NULL;
896 const char *current_group;
897
898 if (filename_vpath == NULL)
899 return 0;
900
901 if (script_vpath != NULL)
902 *script_vpath = NULL;
903
904
905 if (strncmp (action, "View:", 5) == 0)
906 {
907 view_at_line_number = atoi (action + 5);
908 action = "View";
909 }
910
911 if (ext_ini == NULL && !load_extension_file ())
912 return 0;
913
914 mc_stat (filename_vpath, &mystat);
915
916 filename = vfs_path_get_last_path_str (filename_vpath);
917 filename = x_basename (filename);
918 filename_len = strlen (filename);
919
920 if (ext_ini_groups == NULL)
921 ext_ini_groups = mc_config_get_groups (ext_ini, NULL);
922
923
924 for (group_iter = ext_ini_groups; *group_iter != NULL && !found; group_iter++)
925 {
926 enum
927 {
928 TYPE_UNUSED,
929 TYPE_NOT_FOUND,
930 TYPE_FOUND
931 } type_state = TYPE_UNUSED;
932
933 const gchar *g = *group_iter;
934 gchar *pattern;
935 gboolean ignore_case;
936
937 if (strcmp (g, descr_group) == 0 || strncmp (g, "Include/", 8) == 0
938 || strcmp (g, default_group) == 0)
939 continue;
940
941
942
943 pattern = mc_config_get_string_raw (ext_ini, g, "Directory", NULL);
944 if (pattern != NULL)
945 {
946 found = S_ISDIR (mystat.st_mode)
947 && mc_search (pattern, NULL, vfs_path_as_str (filename_vpath), MC_SEARCH_T_REGEX);
948 g_free (pattern);
949
950 continue;
951 }
952
953 #ifdef USE_FILE_CMD
954 if (use_file_to_check_type)
955 {
956 pattern = mc_config_get_string_raw (ext_ini, g, "Type", NULL);
957 if (pattern != NULL)
958 {
959 GError *mcerror = NULL;
960
961 ignore_case = mc_config_get_bool (ext_ini, g, "TypeIgnoreCase", FALSE);
962 type_state =
963 regex_check_type (filename_vpath, pattern, ignore_case, &have_type, &mcerror)
964 ? TYPE_FOUND
965 : TYPE_NOT_FOUND;
966 g_free (pattern);
967
968 if (mc_error_message (&mcerror, NULL))
969 error_flag = TRUE;
970
971 if (type_state == TYPE_NOT_FOUND)
972 continue;
973 }
974 }
975 #endif
976
977 pattern = mc_config_get_string_raw (ext_ini, g, "Regex", NULL);
978 if (pattern != NULL)
979 {
980 mc_search_t *search;
981
982 ignore_case = mc_config_get_bool (ext_ini, g, "RegexIgnoreCase", FALSE);
983 search = mc_search_new (pattern, NULL);
984 g_free (pattern);
985
986 if (search != NULL)
987 {
988 search->search_type = MC_SEARCH_T_REGEX;
989 search->is_case_sensitive = !ignore_case;
990 found = mc_search_run (search, filename, 0, filename_len, NULL);
991 mc_search_free (search);
992 }
993
994 found = found && (type_state == TYPE_UNUSED || type_state == TYPE_FOUND);
995 }
996 else
997 {
998 pattern = mc_config_get_string_raw (ext_ini, g, "Shell", NULL);
999 if (pattern != NULL)
1000 {
1001 int (*cmp_func) (const char *s1, const char *s2, size_t n);
1002 size_t pattern_len;
1003
1004 ignore_case = mc_config_get_bool (ext_ini, g, "ShellIgnoreCase", FALSE);
1005 cmp_func = ignore_case ? strncasecmp : strncmp;
1006 pattern_len = strlen (pattern);
1007
1008 if (*pattern == '.' && filename_len >= pattern_len)
1009 found =
1010 cmp_func (pattern, filename + filename_len - pattern_len, pattern_len) == 0;
1011 else
1012 found = pattern_len == filename_len
1013 && cmp_func (pattern, filename, filename_len) == 0;
1014
1015 g_free (pattern);
1016
1017 found = found && (type_state == TYPE_UNUSED || type_state == TYPE_FOUND);
1018 }
1019 else
1020 found = type_state == TYPE_FOUND;
1021 }
1022 }
1023
1024
1025 if (found)
1026 {
1027 char *include_value;
1028
1029 group_iter--;
1030
1031
1032 include_value = mc_config_get_string_raw (ext_ini, *group_iter, "Include", NULL);
1033 if (include_value != NULL)
1034 {
1035
1036 include_group = g_strconcat ("Include/", include_value, (char *) NULL);
1037 g_free (include_value);
1038 found = mc_config_has_group (ext_ini, include_group);
1039 }
1040 }
1041
1042 if (found)
1043 current_group = include_group != NULL ? include_group : *group_iter;
1044 else
1045 {
1046 current_group = default_group;
1047 found = mc_config_has_group (ext_ini, current_group);
1048 }
1049
1050 if (found && !error_flag)
1051 {
1052 gchar *action_value;
1053
1054 action_value = mc_config_get_string_raw (ext_ini, current_group, action, NULL);
1055 if (action_value == NULL)
1056 {
1057
1058 action_value = mc_config_get_string_raw (ext_ini, default_group, action, NULL);
1059 found = (action_value != NULL && *action_value != '\0');
1060 }
1061 else
1062 {
1063
1064 found = (*action_value != '\0');
1065 }
1066
1067 if (found)
1068 {
1069 vfs_path_t *sv;
1070
1071 sv = exec_extension (current_panel, target, filename_vpath, action_value,
1072 view_at_line_number);
1073 if (script_vpath != NULL)
1074 *script_vpath = sv;
1075 else
1076 exec_cleanup_script (sv);
1077
1078 ret = 1;
1079 }
1080
1081 g_free (action_value);
1082 }
1083
1084 g_free (include_group);
1085
1086 return (error_flag ? -1 : ret);
1087 }
1088
1089