src/filemanager/usermenu.c

   1 /*
   2    User Menu implementation
   3
   4    Copyright (C) 1994, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
   5    2006, 2007, 2011
   6    The Free Software Foundation, Inc.
   7
   8    This file is part of the Midnight Commander.
   9
  10    The Midnight Commander is free software: you can redistribute it
  11    and/or modify it under the terms of the GNU General Public License as
  12    published by the Free Software Foundation, either version 3 of the License,
  13    or (at your option) any later version.
  14
  15    The Midnight Commander is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22  */
  23
  24 /** \file usermenu.c
  25  *  \brief Source: user menu implementation
  26  */
  27
  28 #include <config.h>
  29
  30 #include <ctype.h>
  31 #include <errno.h>
  32 #include <stdlib.h>
  33 #include <stdio.h>
  34 #include <string.h>
  35
  36 #include "lib/global.h"
  37 #include "lib/tty/tty.h"
  38 #include "lib/skin.h"
  39 #include "lib/search.h"
  40 #include "lib/vfs/vfs.h"
  41 #include "lib/strutil.h"
  42 #include "lib/util.h"
  43 #include "lib/widget.h"
  44
  45 #include "src/editor/edit.h"    /* WEdit, BLOCK_FILE */
  46 #include "src/viewer/mcviewer.h"        /* for default_* externs */
  47
  48 #include "src/execute.h"
  49 #include "src/setup.h"
  50 #include "src/history.h"
  51
  52 #include "dir.h"
  53 #include "midnight.h"
  54 #include "layout.h"
  55
  56 #include "usermenu.h"
  57
  58 /*** global variables ****************************************************************************/
  59
  60 /*** file scope macro definitions ****************************************************************/
  61
  62 #define MAX_ENTRIES 16
  63 #define MAX_ENTRY_LEN 60
  64
  65 /*** file scope type declarations ****************************************************************/
  66
  67 /*** file scope variables ************************************************************************/
  68
  69 static int debug_flag = 0;
  70 static int debug_error = 0;
  71 static char *menu = NULL;
  72
  73 /*** file scope functions ************************************************************************/
  74 /* --------------------------------------------------------------------------------------------- */
  75
  76 /** strip file's extension */
  77 static char *
  78 strip_ext (char *ss)
  79 {
  80     register char *s = ss;
  81     char *e = NULL;
  82     while (*s)
  83     {
  84         if (*s == '.')
  85             e = s;
  86         if (*s == PATH_SEP && e)
  87             e = NULL;           /* '.' in *directory* name */
  88         s++;
  89     }
  90     if (e)
  91         *e = 0;
  92     return ss;
  93 }
  94
  95 /* --------------------------------------------------------------------------------------------- */
  96 /**
  97  * Check for the "shell_patterns" directive.  If it's found and valid,
  98  * interpret it and move the pointer past the directive.  Return the
  99  * current pointer.
 100  */
 101
 102 static char *
 103 check_patterns (char *p)
 104 {
 105     static const char def_name[] = "shell_patterns=";
 106     char *p0 = p;
 107
 108     if (strncmp (p, def_name, sizeof (def_name) - 1) != 0)
 109         return p0;
 110
 111     p += sizeof (def_name) - 1;
 112     if (*p == '1')
 113         easy_patterns = 1;
 114     else if (*p == '0')
 115         easy_patterns = 0;
 116     else
 117         return p0;
 118
 119     /* Skip spaces */
 120     p++;
 121     while (*p == '\n' || *p == '\t' || *p == ' ')
 122         p++;
 123     return p;
 124 }
 125
 126 /* --------------------------------------------------------------------------------------------- */
 127 /** Copies a whitespace separated argument from p to arg. Returns the
 128    point after argument. */
 129
 130 static char *
 131 extract_arg (char *p, char *arg, int size)
 132 {
 133     char *np;
 134
 135     while (*p && (*p == ' ' || *p == '\t' || *p == '\n'))
 136         p++;
 137     /* support quote space .mnu */
 138     while (*p && (*p != ' ' || *(p - 1) == '\\') && *p != '\t' && *p != '\n')
 139     {
 140         np = str_get_next_char (p);
 141         if (np - p >= size)
 142             break;
 143         memcpy (arg, p, np - p);
 144         arg += np - p;
 145         size -= np - p;
 146         p = np;
 147     }
 148     *arg = 0;
 149     if (!*p || *p == '\n')
 150         str_prev_char (&p);
 151     return p;
 152 }
 153
 154 /* --------------------------------------------------------------------------------------------- */
 155 /* Tests whether the selected file in the panel is of any of the types
 156    specified in argument. */
 157
 158 static int
 159 test_type (WPanel * panel, char *arg)
 160 {
 161     int result = 0;             /* False by default */
 162     int st_mode = panel->dir.list[panel->selected].st.st_mode;
 163
 164     for (; *arg != 0; arg++)
 165     {
 166         switch (*arg)
 167         {
 168         case 'n':              /* Not a directory */
 169             result |= !S_ISDIR (st_mode);
 170             break;
 171         case 'r':              /* Regular file */
 172             result |= S_ISREG (st_mode);
 173             break;
 174         case 'd':              /* Directory */
 175             result |= S_ISDIR (st_mode);
 176             break;
 177         case 'l':              /* Link */
 178             result |= S_ISLNK (st_mode);
 179             break;
 180         case 'c':              /* Character special */
 181             result |= S_ISCHR (st_mode);
 182             break;
 183         case 'b':              /* Block special */
 184             result |= S_ISBLK (st_mode);
 185             break;
 186         case 'f':              /* Fifo (named pipe) */
 187             result |= S_ISFIFO (st_mode);
 188             break;
 189         case 's':              /* Socket */
 190             result |= S_ISSOCK (st_mode);
 191             break;
 192         case 'x':              /* Executable */
 193             result |= (st_mode & 0111) ? 1 : 0;
 194             break;
 195         case 't':
 196             result |= panel->marked ? 1 : 0;
 197             break;
 198         default:
 199             debug_error = 1;
 200             break;
 201         }
 202     }
 203     return result;
 204 }
 205
 206 /* --------------------------------------------------------------------------------------------- */
 207 /** Calculates the truth value of the next condition starting from
 208    p. Returns the point after condition. */
 209
 210 static char *
 211 test_condition (WEdit * edit_widget, char *p, int *condition)
 212 {
 213     char arg[256];
 214     const mc_search_type_t search_type = easy_patterns ? MC_SEARCH_T_GLOB : MC_SEARCH_T_REGEX;
 215
 216     /* Handle one condition */
 217     for (; *p != '\n' && *p != '&' && *p != '|'; p++)
 218     {
 219         WPanel *panel = NULL;
 220
 221         /* support quote space .mnu */
 222         if ((*p == ' ' && *(p - 1) != '\\') || *p == '\t')
 223             continue;
 224         if (*p >= 'a')
 225             panel = current_panel;
 226         else if (get_other_type () == view_listing)
 227             panel = other_panel;
 228
 229         *p |= 0x20;
 230
 231         switch (*p++)
 232         {
 233         case '!':
 234             p = test_condition (edit_widget, p, condition);
 235             *condition = !*condition;
 236             str_prev_char (&p);
 237             break;
 238         case 'f':              /* file name pattern */
 239             p = extract_arg (p, arg, sizeof (arg));
 240 #ifdef USE_INTERNAL_EDIT
 241             if (edit_widget != NULL)
 242             {
 243                 char *edit_filename;
 244
 245                 edit_filename = edit_get_file_name (edit_widget);
 246                 *condition = mc_search (arg, edit_filename, search_type) ? 1 : 0;
 247                 g_free (edit_filename);
 248             }
 249             else
 250 #endif
 251                 *condition = panel != NULL &&
 252                     mc_search (arg, panel->dir.list[panel->selected].fname, search_type) ? 1 : 0;
 253             break;
 254         case 'y':              /* syntax pattern */
 255 #ifdef USE_INTERNAL_EDIT
 256             if (edit_widget != NULL)
 257             {
 258                 const char *syntax_type = edit_get_syntax_type (edit_widget);
 259                 if (syntax_type != NULL)
 260                 {
 261                     p = extract_arg (p, arg, sizeof (arg));
 262                     *condition = mc_search (arg, syntax_type, MC_SEARCH_T_NORMAL) ? 1 : 0;
 263                 }
 264             }
 265 #endif
 266             break;
 267         case 'd':
 268             p = extract_arg (p, arg, sizeof (arg));
 269             {
 270                 char *cwd_str;
 271
 272                 cwd_str = vfs_path_to_str (panel->cwd_vpath);
 273                 *condition = panel != NULL && mc_search (arg, cwd_str, search_type) ? 1 : 0;
 274                 g_free (cwd_str);
 275             }
 276             break;
 277         case 't':
 278             p = extract_arg (p, arg, sizeof (arg));
 279             *condition = panel != NULL && test_type (panel, arg) ? 1 : 0;
 280             break;
 281         case 'x':              /* executable */
 282             {
 283                 struct stat status;
 284
 285                 p = extract_arg (p, arg, sizeof (arg));
 286                 if (stat (arg, &status) == 0)
 287                     *condition = is_exe (status.st_mode) ? 1 : 0;
 288                 else
 289                     *condition = 0;
 290                 break;
 291             }
 292         default:
 293             debug_error = 1;
 294             break;
 295         }                       /* switch */
 296
 297     }                           /* while */
 298     return p;
 299 }
 300
 301 /* --------------------------------------------------------------------------------------------- */
 302 /** General purpose condition debug output handler */
 303
 304 static void
 305 debug_out (char *start, char *end, int cond)
 306 {
 307     static char *msg;
 308     int len;
 309
 310     if (start == NULL && end == NULL)
 311     {
 312         /* Show output */
 313         if (debug_flag && msg)
 314         {
 315             len = strlen (msg);
 316             if (len)
 317                 msg[len - 1] = 0;
 318             message (D_NORMAL, _("Debug"), "%s", msg);
 319
 320         }
 321         debug_flag = 0;
 322         g_free (msg);
 323         msg = NULL;
 324     }
 325     else
 326     {
 327         const char *type;
 328         char *p;
 329
 330         /* Save debug info for later output */
 331         if (!debug_flag)
 332             return;
 333         /* Save the result of the condition */
 334         if (debug_error)
 335         {
 336             type = _("ERROR:");
 337             debug_error = 0;
 338         }
 339         else if (cond)
 340             type = _("True:");
 341         else
 342             type = _("False:");
 343         /* This is for debugging, don't need to be super efficient.  */
 344         if (end == NULL)
 345             p = g_strdup_printf ("%s %s %c \n", msg ? msg : "", type, *start);
 346         else
 347             p = g_strdup_printf ("%s %s %.*s \n", msg ? msg : "", type, (int) (end - start), start);
 348         g_free (msg);
 349         msg = p;
 350     }
 351 }
 352
 353 /* --------------------------------------------------------------------------------------------- */
 354 /** Calculates the truth value of one lineful of conditions. Returns
 355    the point just before the end of line. */
 356
 357 static char *
 358 test_line (WEdit * edit_widget, char *p, int *result)
 359 {
 360     int condition;
 361     char operator;
 362     char *debug_start, *debug_end;
 363
 364     /* Repeat till end of line */
 365     while (*p && *p != '\n')
 366     {
 367         /* support quote space .mnu */
 368         while ((*p == ' ' && *(p - 1) != '\\') || *p == '\t')
 369             p++;
 370         if (!*p || *p == '\n')
 371             break;
 372         operator = *p++;
 373         if (*p == '?')
 374         {
 375             debug_flag = 1;
 376             p++;
 377         }
 378         /* support quote space .mnu */
 379         while ((*p == ' ' && *(p - 1) != '\\') || *p == '\t')
 380             p++;
 381         if (!*p || *p == '\n')
 382             break;
 383         condition = 1;          /* True by default */
 384
 385         debug_start = p;
 386         p = test_condition (edit_widget, p, &condition);
 387         debug_end = p;
 388         /* Add one debug statement */
 389         debug_out (debug_start, debug_end, condition);
 390
 391         switch (operator)
 392         {
 393         case '+':
 394         case '=':
 395             /* Assignment */
 396             *result = condition;
 397             break;
 398         case '&':              /* Logical and */
 399             *result &= condition;
 400             break;
 401         case '|':              /* Logical or */
 402             *result |= condition;
 403             break;
 404         default:
 405             debug_error = 1;
 406             break;
 407         }                       /* switch */
 408         /* Add one debug statement */
 409         debug_out (&operator, NULL, *result);
 410
 411     }                           /* while (*p != '\n') */
 412     /* Report debug message */
 413     debug_out (NULL, NULL, 1);
 414
 415     if (!*p || *p == '\n')
 416         str_prev_char (&p);
 417     return p;
 418 }
 419
 420 /* --------------------------------------------------------------------------------------------- */
 421 /** FIXME: recode this routine on version 3.0, it could be cleaner */
 422
 423 static void
 424 execute_menu_command (WEdit * edit_widget, const char *commands, gboolean show_prompt)
 425 {
 426     FILE *cmd_file;
 427     int cmd_file_fd;
 428     int expand_prefix_found = 0;
 429     char *parameter = 0;
 430     gboolean do_quote = FALSE;
 431     char lc_prompt[80];
 432     int col;
 433     vfs_path_t *file_name_vpath;
 434     int run_view = 0;
 435
 436     /* Skip menu entry title line */
 437     commands = strchr (commands, '\n');
 438     if (!commands)
 439     {
 440         return;
 441     }
 442
 443     cmd_file_fd = mc_mkstemps (&file_name_vpath, "mcusr", SCRIPT_SUFFIX);
 444
 445     if (cmd_file_fd == -1)
 446     {
 447         message (D_ERROR, MSG_ERROR, _("Cannot create temporary command file\n%s"),
 448                  unix_error_string (errno));
 449         vfs_path_free (file_name_vpath);
 450         return;
 451     }
 452     cmd_file = fdopen (cmd_file_fd, "w");
 453     fputs ("#! /bin/sh\n", cmd_file);
 454     commands++;
 455
 456     for (col = 0; *commands; commands++)
 457     {
 458         if (col == 0)
 459         {
 460             if (*commands != ' ' && *commands != '\t')
 461                 break;
 462             while (*commands == ' ' || *commands == '\t')
 463                 commands++;
 464             if (*commands == 0)
 465                 break;
 466         }
 467         col++;
 468         if (*commands == '\n')
 469             col = 0;
 470         if (parameter)
 471         {
 472             if (*commands == '}')
 473             {
 474                 char *tmp;
 475                 *parameter = 0;
 476                 parameter =
 477                     input_dialog (_("Parameter"), lc_prompt, MC_HISTORY_FM_MENU_EXEC_PARAM, "",
 478                                   INPUT_COMPLETE_FILENAMES | INPUT_COMPLETE_CD |
 479                                   INPUT_COMPLETE_HOSTNAMES | INPUT_COMPLETE_VARIABLES |
 480                                   INPUT_COMPLETE_USERNAMES);
 481                 if (!parameter || !*parameter)
 482                 {
 483                     /* User canceled */
 484                     fclose (cmd_file);
 485                     mc_unlink (file_name_vpath);
 486                     vfs_path_free (file_name_vpath);
 487                     return;
 488                 }
 489                 if (do_quote)
 490                 {
 491                     tmp = name_quote (parameter, 0);
 492                     fputs (tmp, cmd_file);
 493                     g_free (tmp);
 494                 }
 495                 else
 496                     fputs (parameter, cmd_file);
 497                 g_free (parameter);
 498                 parameter = 0;
 499             }
 500             else
 501             {
 502                 if (parameter < &lc_prompt[sizeof (lc_prompt) - 1])
 503                 {
 504                     *parameter++ = *commands;
 505                 }
 506             }
 507         }
 508         else if (expand_prefix_found)
 509         {
 510             expand_prefix_found = 0;
 511             if (g_ascii_isdigit ((gchar) * commands))
 512             {
 513                 do_quote = (atoi (commands) != 0);
 514                 while (g_ascii_isdigit ((gchar) * commands))
 515                     commands++;
 516             }
 517             if (*commands == '{')
 518                 parameter = lc_prompt;
 519             else
 520             {
 521                 char *text = expand_format (edit_widget, *commands, do_quote);
 522                 fputs (text, cmd_file);
 523                 g_free (text);
 524             }
 525         }
 526         else
 527         {
 528             if (*commands == '%')
 529             {
 530                 int i = check_format_view (commands + 1);
 531                 if (i)
 532                 {
 533                     commands += i;
 534                     run_view = 1;
 535                 }
 536                 else
 537                 {
 538                     do_quote = TRUE;    /* Default: Quote expanded macro */
 539                     expand_prefix_found = 1;
 540                 }
 541             }
 542             else
 543                 fputc (*commands, cmd_file);
 544         }
 545     }
 546     fclose (cmd_file);
 547     mc_chmod (file_name_vpath, S_IRWXU);
 548     if (run_view)
 549     {
 550         char *file_name;
 551
 552         file_name = vfs_path_to_str (file_name_vpath);
 553         mcview_viewer (file_name, NULL, 0);
 554         g_free (file_name);
 555         dialog_switch_process_pending ();
 556     }
 557     else
 558     {
 559         /* execute the command indirectly to allow execution even
 560          * on no-exec filesystems. */
 561         char *file_name, *cmd;
 562
 563         file_name = vfs_path_to_str (file_name_vpath);
 564         cmd = g_strconcat ("/bin/sh ", file_name, (char *) NULL);
 565         g_free (file_name);
 566         if (!show_prompt)
 567         {
 568             if (system (cmd) == -1)
 569                 message (D_ERROR, MSG_ERROR, "%s", _("Error calling program"));
 570         }
 571         else
 572         {
 573             shell_execute (cmd, EXECUTE_HIDE);
 574         }
 575         g_free (cmd);
 576     }
 577     mc_unlink (file_name_vpath);
 578     vfs_path_free (file_name_vpath);
 579 }
 580
 581 /* --------------------------------------------------------------------------------------------- */
 582 /**
 583  **     Check owner of the menu file. Using menu file is allowed, if
 584  **     owner of the menu is root or the actual user. In either case
 585  **     file should not be group and word-writable.
 586  **
 587  **     Q. Should we apply this routine to system and home menu (and .ext files)?
 588  */
 589
 590 static int
 591 menu_file_own (char *path)
 592 {
 593     struct stat st;
 594
 595     if (stat (path, &st) == 0
 596         && (!st.st_uid || (st.st_uid == geteuid ())) && ((st.st_mode & (S_IWGRP | S_IWOTH)) == 0))
 597     {
 598         return 1;
 599     }
 600     if (verbose)
 601     {
 602         message (D_NORMAL, _("Warning -- ignoring file"),
 603                  _("File %s is not owned by root or you or is world writable.\n"
 604                    "Using it may compromise your security"), path);
 605     }
 606     return 0;
 607 }
 608
 609 /* --------------------------------------------------------------------------------------------- */
 610 /*** public functions ****************************************************************************/
 611 /* --------------------------------------------------------------------------------------------- */
 612
 613 /* Formats defined:
 614    %%  The % character
 615    %f  The current file (if non-local vfs, file will be copied locally and
 616    %f will be full path to it).
 617    %p  The current file
 618    %d  The current working directory
 619    %s  "Selected files"; the tagged files if any, otherwise the current file
 620    %t  Tagged files
 621    %u  Tagged files (and they are untagged on return from expand_format)
 622    %view Runs the commands and pipes standard output to the view command.
 623    If %view is immediately followed by '{', recognize keywords
 624    ascii, hex, nroff and unform
 625
 626    If the format letter is in uppercase, it refers to the other panel.
 627
 628    With a number followed the % character you can turn quoting on (default)
 629    and off. For example:
 630    %f    quote expanded macro
 631    %1f   ditto
 632    %0f   don't quote expanded macro
 633
 634    expand_format returns a memory block that must be free()d.
 635  */
 636
 637 /* Returns how many characters we should advance if %view was found */
 638 int
 639 check_format_view (const char *p)
 640 {
 641     const char *q = p;
 642     if (!strncmp (p, "view", 4))
 643     {
 644         q += 4;
 645         if (*q == '{')
 646         {
 647             for (q++; *q && *q != '}'; q++)
 648             {
 649                 if (!strncmp (q, "ascii", 5))
 650                 {
 651                     mcview_default_hex_mode = 0;
 652                     q += 4;
 653                 }
 654                 else if (!strncmp (q, "hex", 3))
 655                 {
 656                     mcview_default_hex_mode = 1;
 657                     q += 2;
 658                 }
 659                 else if (!strncmp (q, "nroff", 5))
 660                 {
 661                     mcview_default_nroff_flag = 1;
 662                     q += 4;
 663                 }
 664                 else if (!strncmp (q, "unform", 6))
 665                 {
 666                     mcview_default_nroff_flag = 0;
 667                     q += 5;
 668                 }
 669             }
 670             if (*q == '}')
 671                 q++;
 672         }
 673         return q - p;
 674     }
 675     return 0;
 676 }
 677
 678 /* --------------------------------------------------------------------------------------------- */
 679
 680 int
 681 check_format_cd (const char *p)
 682 {
 683     return (strncmp (p, "cd", 2)) ? 0 : 3;
 684 }
 685
 686 /* --------------------------------------------------------------------------------------------- */
 687 /* Check if p has a "^var\{var-name\}" */
 688 /* Returns the number of skipped characters (zero on not found) */
 689 /* V will be set to the expanded variable name */
 690
 691 int
 692 check_format_var (const char *p, char **v)
 693 {
 694     const char *q = p;
 695     char *var_name;
 696     const char *value;
 697     const char *dots = 0;
 698
 699     *v = 0;
 700     if (!strncmp (p, "var{", 4))
 701     {
 702         for (q += 4; *q && *q != '}'; q++)
 703         {
 704             if (*q == ':')
 705                 dots = q + 1;
 706         }
 707         if (!*q)
 708             return 0;
 709
 710         if (!dots || dots == q + 5)
 711         {
 712             message (D_ERROR,
 713                      _("Format error on file Extensions File"),
 714                      !dots ? _("The %%var macro has no default")
 715                      : _("The %%var macro has no variable"));
 716             return 0;
 717         }
 718
 719         /* Copy the variable name */
 720         var_name = g_strndup (p + 4, dots - 2 - (p + 3));
 721
 722         value = getenv (var_name);
 723         g_free (var_name);
 724         if (value)
 725         {
 726             *v = g_strdup (value);
 727             return q - p;
 728         }
 729         var_name = g_strndup (dots, q - dots);
 730         *v = var_name;
 731         return q - p;
 732     }
 733     return 0;
 734 }
 735
 736 /* --------------------------------------------------------------------------------------------- */
 737
 738 char *
 739 expand_format (struct WEdit *edit_widget, char c, gboolean do_quote)
 740 {
 741     WPanel *panel = NULL;
 742     char *(*quote_func) (const char *, int);
 743     char *fname = NULL;
 744     char *result;
 745     char c_lc;
 746
 747 #ifndef USE_INTERNAL_EDIT
 748     (void) edit_widget;
 749 #endif
 750
 751     if (c == '%')
 752         return g_strdup ("%");
 753
 754     switch (mc_global.mc_run_mode)
 755     {
 756     case MC_RUN_FULL:
 757         if (g_ascii_islower ((gchar) c))
 758             panel = current_panel;
 759         else
 760         {
 761             if (get_other_type () != view_listing)
 762                 return g_strdup ("");
 763             panel = other_panel;
 764         }
 765         fname = g_strdup (panel->dir.list[panel->selected].fname);
 766         break;
 767
 768 #ifdef USE_INTERNAL_EDIT
 769     case MC_RUN_EDITOR:
 770         fname = edit_get_file_name (edit_widget);
 771         break;
 772 #endif
 773
 774     default:
 775         /* other modes don't use formats */
 776         return g_strdup ("");
 777     }
 778
 779     if (do_quote)
 780         quote_func = name_quote;
 781     else
 782         quote_func = fake_name_quote;
 783
 784     c_lc = g_ascii_tolower ((gchar) c);
 785
 786     switch (c_lc)
 787     {
 788     case 'f':
 789     case 'p':
 790         result = (*quote_func) (fname, 0);
 791         goto ret;
 792     case 'x':
 793         result = (*quote_func) (extension (fname), 0);
 794         goto ret;
 795     case 'd':
 796         {
 797             char *cwd;
 798             char *qstr;
 799
 800             if (panel)
 801                 cwd = vfs_path_to_str (panel->cwd_vpath);
 802             else
 803                 cwd = vfs_get_current_dir ();
 804
 805             qstr = (*quote_func) (cwd, 0);
 806
 807             g_free (cwd);
 808
 809             result = qstr;
 810             goto ret;
 811         }
 812     case 'i':                  /* indent equal number cursor position in line */
 813 #ifdef USE_INTERNAL_EDIT
 814         if (edit_widget)
 815         {
 816             result = g_strnfill (edit_get_curs_col (edit_widget), ' ');
 817             goto ret;
 818         }
 819 #endif
 820         break;
 821     case 'y':                  /* syntax type */
 822 #ifdef USE_INTERNAL_EDIT
 823         if (edit_widget)
 824         {
 825             const char *syntax_type = edit_get_syntax_type (edit_widget);
 826             if (syntax_type != NULL)
 827             {
 828                 result = g_strdup (syntax_type);
 829                 goto ret;
 830             }
 831         }
 832 #endif
 833         break;
 834     case 'k':                  /* block file name */
 835     case 'b':                  /* block file name / strip extension */
 836         {
 837 #ifdef USE_INTERNAL_EDIT
 838             if (edit_widget)
 839             {
 840                 char *file;
 841
 842                 file = mc_config_get_full_path (EDIT_BLOCK_FILE);
 843                 result = (*quote_func) (file, 0);
 844                 g_free (file);
 845                 goto ret;
 846             }
 847 #endif
 848             if (c_lc == 'b')
 849             {
 850                 result = strip_ext ((*quote_func) (fname, 0));
 851                 goto ret;
 852             }
 853             break;
 854         }
 855     case 'n':                  /* strip extension in editor */
 856 #ifdef USE_INTERNAL_EDIT
 857         if (edit_widget)
 858         {
 859             result = strip_ext ((*quote_func) (fname, 0));
 860             goto ret;
 861         }
 862 #endif
 863         break;
 864     case 'm':                  /* menu file name */
 865         if (menu)
 866         {
 867             result = (*quote_func) (menu, 0);
 868             goto ret;
 869         }
 870         break;
 871     case 's':
 872         if (!panel || !panel->marked)
 873         {
 874             result = (*quote_func) (fname, 0);
 875             goto ret;
 876         }
 877
 878         /* Fall through */
 879
 880     case 't':
 881     case 'u':
 882         {
 883             GString *block;
 884             int i;
 885
 886             if (panel == NULL)
 887             {
 888                 result = g_strdup ("");
 889                 goto ret;
 890             }
 891
 892             block = g_string_sized_new (16);
 893
 894             for (i = 0; i < panel->count; i++)
 895                 if (panel->dir.list[i].f.marked)
 896                 {
 897                     char *tmp;
 898
 899                     tmp = (*quote_func) (panel->dir.list[i].fname, 0);
 900                     g_string_append (block, tmp);
 901                     g_string_append_c (block, ' ');
 902                     g_free (tmp);
 903
 904                     if (c_lc == 'u')
 905                         do_file_mark (panel, i, 0);
 906                 }
 907             result = g_string_free (block, FALSE);
 908             goto ret;
 909         }                       /* sub case block */
 910     }                           /* switch */
 911     result = g_strdup ("% ");
 912     result[1] = c;
 913   ret:
 914     g_free (fname);
 915     return result;
 916 }
 917
 918 /* --------------------------------------------------------------------------------------------- */
 919 /**
 920  * If edit_widget is NULL then we are called from the mc menu,
 921  * otherwise we are called from the mcedit menu.
 922  */
 923
 924 gboolean
 925 user_menu_cmd (struct WEdit * edit_widget, const char *menu_file, int selected_entry)
 926 {
 927     char *p;
 928     char *data, **entries;
 929     int max_cols, menu_lines, menu_limit;
 930     int col, i, accept_entry = 1;
 931     int selected, old_patterns;
 932     Listbox *listbox;
 933     gboolean res = FALSE;
 934     gboolean interactive = TRUE;
 935
 936     if (!vfs_current_is_local ())
 937     {
 938         message (D_ERROR, MSG_ERROR, "%s", _("Cannot execute commands on non-local filesystems"));
 939         return FALSE;
 940     }
 941     if (menu_file != NULL)
 942         menu = g_strdup (menu_file);
 943     else
 944         menu = g_strdup (edit_widget ? EDIT_LOCAL_MENU : MC_LOCAL_MENU);
 945     if (!exist_file (menu) || !menu_file_own (menu))
 946     {
 947         if (menu_file != NULL)
 948         {
 949             message (D_ERROR, MSG_ERROR, _("Cannot open file %s\n%s"), menu,
 950                      unix_error_string (errno));
 951             g_free (menu);
 952             menu = NULL;
 953             return FALSE;
 954         }
 955
 956         g_free (menu);
 957         if (edit_widget)
 958             menu = mc_config_get_full_path (EDIT_HOME_MENU);
 959         else
 960             menu = mc_config_get_full_path (MC_USERMENU_FILE);
 961
 962
 963         if (!exist_file (menu))
 964         {
 965             g_free (menu);
 966             menu =
 967                 mc_build_filename (mc_config_get_home_dir (),
 968                                    edit_widget ? EDIT_GLOBAL_MENU : MC_GLOBAL_MENU, NULL);
 969             if (!exist_file (menu))
 970             {
 971                 g_free (menu);
 972                 menu =
 973                     mc_build_filename (mc_global.sysconfig_dir,
 974                                        edit_widget ? EDIT_GLOBAL_MENU : MC_GLOBAL_MENU, NULL);
 975                 if (!exist_file (menu))
 976                 {
 977                     g_free (menu);
 978                     menu = mc_build_filename
 979                         (mc_global.share_data_dir, edit_widget ? EDIT_GLOBAL_MENU : MC_GLOBAL_MENU,
 980                          NULL);
 981                 }
 982             }
 983         }
 984     }
 985
 986     if (!g_file_get_contents (menu, &data, NULL, NULL))
 987     {
 988         message (D_ERROR, MSG_ERROR, _("Cannot open file%s\n%s"), menu, unix_error_string (errno));
 989         g_free (menu);
 990         menu = NULL;
 991         return FALSE;
 992     }
 993
 994     max_cols = 0;
 995     selected = 0;
 996     menu_limit = 0;
 997     entries = 0;
 998
 999     /* Parse the menu file */
1000     old_patterns = easy_patterns;
1001     p = check_patterns (data);
1002     for (menu_lines = col = 0; *p; str_next_char (&p))
1003     {
1004         if (menu_lines >= menu_limit)
1005         {
1006             char **new_entries;
1007
1008             menu_limit += MAX_ENTRIES;
1009             new_entries = g_try_realloc (entries, sizeof (new_entries[0]) * menu_limit);
1010
1011             if (new_entries == NULL)
1012                 break;
1013
1014             entries = new_entries;
1015             new_entries += menu_limit;
1016             while (--new_entries >= &entries[menu_lines])
1017                 *new_entries = NULL;
1018         }
1019         if (col == 0 && !entries[menu_lines])
1020         {
1021             if (*p == '#')
1022             {
1023                 /* show prompt if first line of external script is #interactive */
1024                 if (selected_entry >= 0 && strncmp (p, "#silent", 7) == 0)
1025                     interactive = FALSE;
1026                 /* A commented menu entry */
1027                 accept_entry = 1;
1028             }
1029             else if (*p == '+')
1030             {
1031                 if (*(p + 1) == '=')
1032                 {
1033                     /* Combined adding and default */
1034                     p = test_line (edit_widget, p + 1, &accept_entry);
1035                     if (selected == 0 && accept_entry)
1036                         selected = menu_lines;
1037                 }
1038                 else
1039                 {
1040                     /* A condition for adding the entry */
1041                     p = test_line (edit_widget, p, &accept_entry);
1042                 }
1043             }
1044             else if (*p == '=')
1045             {
1046                 if (*(p + 1) == '+')
1047                 {
1048                     /* Combined adding and default */
1049                     p = test_line (edit_widget, p + 1, &accept_entry);
1050                     if (selected == 0 && accept_entry)
1051                         selected = menu_lines;
1052                 }
1053                 else
1054                 {
1055                     /* A condition for making the entry default */
1056                     i = 1;
1057                     p = test_line (edit_widget, p, &i);
1058                     if (selected == 0 && i)
1059                         selected = menu_lines;
1060                 }
1061             }
1062             else if (*p != ' ' && *p != '\t' && str_isprint (p))
1063             {
1064                 /* A menu entry title line */
1065                 if (accept_entry)
1066                     entries[menu_lines] = p;
1067                 else
1068                     accept_entry = 1;
1069             }
1070         }
1071         if (*p == '\n')
1072         {
1073             if (entries[menu_lines])
1074             {
1075                 menu_lines++;
1076                 accept_entry = 1;
1077             }
1078             max_cols = max (max_cols, col);
1079             col = 0;
1080         }
1081         else
1082         {
1083             if (*p == '\t')
1084                 *p = ' ';
1085             col++;
1086         }
1087     }
1088
1089     if (menu_lines == 0)
1090     {
1091         message (D_ERROR, MSG_ERROR, _("No suitable entries found in %s"), menu);
1092         res = FALSE;
1093     }
1094     else
1095     {
1096         if (selected_entry >= 0)
1097             selected = selected_entry;
1098         else
1099         {
1100             max_cols = min (max (max_cols, col), MAX_ENTRY_LEN);
1101
1102             /* Create listbox */
1103             listbox = create_listbox_window (menu_lines, max_cols + 2, _("User menu"),
1104                                              "[Menu File Edit]");
1105             /* insert all the items found */
1106             for (i = 0; i < menu_lines; i++)
1107             {
1108                 p = entries[i];
1109                 LISTBOX_APPEND_TEXT (listbox, (unsigned char) p[0],
1110                                      extract_line (p, p + MAX_ENTRY_LEN), p);
1111             }
1112             /* Select the default entry */
1113             listbox_select_entry (listbox->list, selected);
1114
1115             selected = run_listbox (listbox);
1116         }
1117         if (selected >= 0)
1118         {
1119             execute_menu_command (edit_widget, entries[selected], interactive);
1120             res = TRUE;
1121         }
1122
1123         do_refresh ();
1124     }
1125
1126     easy_patterns = old_patterns;
1127     g_free (menu);
1128     menu = NULL;
1129     g_free (entries);
1130     g_free (data);
1131     return res;
1132 }
1133
1134 /* --------------------------------------------------------------------------------------------- */