ROX-Filer/src/run.c

   1 /*
   2  * ROX-Filer, filer for the ROX desktop project
   3  * Copyright (C) 2006, Thomas Leonard and others (see changelog for details).
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the Free
   7  * Software Foundation; either version 2 of the License, or (at your option)
   8  * any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along with
  16  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  17  * Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19
  20 /* run.c */
  21
  22 #include "config.h"
  23
  24 #include <errno.h>
  25 #include <string.h>
  26 #include <sys/param.h>
  27
  28 #include "global.h"
  29
  30 #include "run.h"
  31 #include "support.h"
  32 #include "gui_support.h"
  33 #include "filer.h"
  34 #include "display.h"
  35 #include "main.h"
  36 #include "type.h"
  37 #include "dir.h"
  38 #include "diritem.h"
  39 #include "action.h"
  40 #include "icon.h"
  41
  42 /* Static prototypes */
  43 static void write_data(gpointer data, gint fd, GdkInputCondition cond);
  44 static gboolean follow_symlink(const char *full_path,
  45                                FilerWindow *filer_window,
  46                                FilerWindow *src_window);
  47 static gboolean open_file(const guchar *path, MIME_type *type);
  48 static void open_mountpoint(const guchar *full_path, DirItem *item,
  49                             FilerWindow *filer_window, FilerWindow *src_window,
  50                             gboolean edit);
  51 static gboolean run_desktop(const char *full_path,
  52                             const char **args, const char *dir);
  53 static gboolean type_open(const char *path, MIME_type *type);
  54
  55 typedef struct _PipedData PipedData;
  56
  57 struct _PipedData
  58 {
  59         guchar          *data;
  60         gint            tag;
  61         gulong          sent;
  62         gulong          length;
  63 };
  64
  65
  66 /****************************************************************
  67  *                      EXTERNAL INTERFACE                      *
  68  ****************************************************************/
  69
  70
  71 /* An application has been double-clicked (or run in some other way) */
  72 void run_app(const char *path)
  73 {
  74         GString *apprun;
  75         const char *argv[] = {NULL, NULL};
  76
  77         apprun = g_string_new(path);
  78         argv[0] = g_string_append(apprun, "/AppRun")->str;
  79
  80         rox_spawn(home_dir, argv);
  81
  82         g_string_free(apprun, TRUE);
  83 }
  84
  85 /* Execute this program, passing all the URIs in the list as arguments.
  86  * URIs that are files on the local machine will be passed as simple
  87  * pathnames. The uri_list should be freed after this function returns.
  88  */
  89 void run_with_files(const char *path, GList *uri_list)
  90 {
  91         const char      **argv;
  92         int             argc = 0, i;
  93         struct stat     info;
  94         MIME_type       *type;
  95
  96         if (stat(path, &info))
  97         {
  98                 delayed_error(_("Program %s not found - deleted?"), path);
  99                 return;
 100         }
 101
 102         argv = g_malloc(sizeof(char *) * (g_list_length(uri_list) + 2));
 103
 104         if (S_ISDIR(info.st_mode))
 105                 argv[argc++] = make_path(path, "AppRun");
 106         else
 107                 argv[argc++] = path;
 108
 109         while (uri_list)
 110         {
 111                 const EscapedPath *uri = uri_list->data;
 112                 char *local;
 113
 114                 local = get_local_path(uri);
 115                 if (local)
 116                         argv[argc++] = local;
 117                 else
 118                         argv[argc++] = unescape_uri(uri);
 119                 uri_list = uri_list->next;
 120         }
 121
 122         argv[argc++] = NULL;
 123
 124         type = type_from_path(argv[0]);
 125         if (type && type == application_x_desktop)
 126         {
 127                 run_desktop(argv[0], argv + 1, home_dir);
 128         }
 129         else
 130         {
 131                 rox_spawn(home_dir, argv);
 132         }
 133
 134         for (i = 1; i < argc; i++)
 135                 g_free((gchar *) argv[i]);
 136         g_free(argv);
 137 }
 138
 139 /* Run the program as '<path> -', piping the data to it via stdin.
 140  * You can g_free() the data as soon as this returns.
 141  */
 142 void run_with_data(const char *path, gpointer data, gulong length)
 143 {
 144         const char      *argv[] = {NULL, "-", NULL};
 145         struct stat     info;
 146         int             fds[2];
 147         PipedData       *pd;
 148
 149         if (stat(path, &info))
 150         {
 151                 delayed_error(_("Program %s not found - deleted?"), path);
 152                 return;
 153         }
 154
 155         if (S_ISDIR(info.st_mode))
 156                 argv[0] = make_path(path, "AppRun");
 157         else
 158                 argv[0] = path;
 159
 160         if (pipe(fds))
 161         {
 162                 delayed_error("pipe: %s", g_strerror(errno));
 163                 return;
 164         }
 165         close_on_exec(fds[1], TRUE);
 166         close_on_exec(fds[0], TRUE);
 167
 168         switch (fork())
 169         {
 170                 case -1:
 171                         delayed_error("fork: %s", g_strerror(errno));
 172                         close(fds[1]);
 173                         break;
 174                 case 0:
 175                         /* We are the child */
 176                         chdir(home_dir);
 177                         if (dup2(fds[0], 0) == -1)
 178                                 g_warning("dup2() failed: %s\n",
 179                                                 g_strerror(errno));
 180                         else
 181                         {
 182                                 close_on_exec(0, FALSE);
 183                                 if (execv(argv[0], (char **) argv))
 184                                         g_warning("execv(%s) failed: %s\n",
 185                                                 argv[0], g_strerror(errno));
 186                         }
 187                         _exit(1);
 188                 default:
 189                         /* We are the parent */
 190                         set_blocking(fds[1], FALSE);
 191                         pd = g_new(PipedData, 1);
 192                         pd->data = g_malloc(length);
 193                         memcpy(pd->data, data, length);
 194                         pd->length = length;
 195                         pd->sent = 0;
 196                         pd->tag = gdk_input_add_full(fds[1], GDK_INPUT_WRITE,
 197                                                 write_data, pd, NULL);
 198                         break;
 199         }
 200
 201         close(fds[0]);
 202 }
 203
 204 /* Splits args into an argument vector, and runs the program. Must be
 205  * executable.
 206  */
 207 void run_with_args(const char *path, DirItem *item, const char *args)
 208 {
 209         GError *error = NULL;
 210         gchar **argv = NULL;
 211         int n_args = 0;
 212
 213         if (item->base_type != TYPE_DIRECTORY && item->base_type != TYPE_FILE)
 214         {
 215                 delayed_error("Arguments (%s) given for non-executable item %s",
 216                                 args, path);
 217                 return;
 218         }
 219
 220         if (!g_shell_parse_argv(args, &n_args, &argv, &error))
 221         {
 222                 delayed_error("Failed to parse argument string '%s':\n%s",
 223                                 args, error->message);
 224                 g_error_free(error);
 225                 return;
 226         }
 227
 228         g_return_if_fail(argv != NULL);
 229         g_return_if_fail(error == NULL);
 230
 231         argv = g_realloc(argv, (n_args + 2) * sizeof(gchar *));
 232         memmove(argv + 1, argv, (n_args + 1) * sizeof(gchar *));
 233
 234         if (item->base_type == TYPE_DIRECTORY)
 235                 argv[0] = g_strconcat(path, "/AppRun", NULL);
 236         else
 237                 argv[0] = g_strdup(path);
 238
 239         rox_spawn(home_dir, (const gchar **) argv);
 240
 241         g_strfreev(argv);
 242 }
 243
 244 /* Load a file, open a directory or run an application. Or, if 'edit' is set:
 245  * edit a file, open an application, follow a symlink or mount a device.
 246  *
 247  * filer_window is the window to use for displaying a directory.
 248  * NULL will always use a new directory when needed.
 249  * src_window is the window to copy options from, or NULL.
 250  *
 251  * Returns TRUE on success.
 252  */
 253 gboolean run_diritem(const guchar *full_path,
 254                      DirItem *item,
 255                      FilerWindow *filer_window,
 256                      FilerWindow *src_window,
 257                      gboolean edit)
 258 {
 259         if (item->flags & ITEM_FLAG_SYMLINK && edit)
 260                 return follow_symlink(full_path, filer_window, src_window);
 261
 262         switch (item->base_type)
 263         {
 264                 case TYPE_DIRECTORY:
 265                         if (item->flags & ITEM_FLAG_APPDIR && !edit)
 266                         {
 267                                 run_app(full_path);
 268                                 return TRUE;
 269                         }
 270
 271                         if (item->flags & ITEM_FLAG_MOUNT_POINT)
 272                         {
 273                                 open_mountpoint(full_path, item,
 274                                                 filer_window, src_window, edit);
 275                         }
 276                         else if (filer_window)
 277                                 filer_change_to(filer_window, full_path, NULL);
 278                         else
 279                                 filer_opendir(full_path, src_window, NULL);
 280                         return TRUE;
 281                 case TYPE_FILE:
 282                         if (EXECUTABLE_FILE(item) && !edit)
 283                         {
 284                                 const char *argv[] = {NULL, NULL};
 285                                 guchar  *dir = filer_window
 286                                                 ? filer_window->sym_path
 287                                                 : NULL;
 288
 289                                 if (item->mime_type == application_x_desktop)
 290                                         return run_desktop(full_path,
 291                                                            NULL, dir);
 292                                 else
 293                                         argv[0] = full_path;
 294
 295                                 return rox_spawn(dir, argv) != 0;
 296                         }
 297
 298                         return open_file(full_path, edit ? text_plain
 299                                                   : item->mime_type);
 300                 case TYPE_ERROR:
 301                         delayed_error(_("File doesn't exist, or I can't "
 302                                           "access it: %s"), full_path);
 303                         return FALSE;
 304                 default:
 305                         delayed_error(
 306                                 _("I don't know how to open '%s'"), full_path);
 307                         return FALSE;
 308         }
 309 }
 310
 311 /* Attempt to open this item */
 312 gboolean run_by_path(const guchar *full_path)
 313 {
 314         gboolean retval;
 315         DirItem *item;
 316
 317         /* XXX: Loads an image - wasteful */
 318         item = diritem_new("");
 319         diritem_restat(full_path, item, NULL);
 320         retval = run_diritem(full_path, item, NULL, NULL, FALSE);
 321         diritem_free(item);
 322
 323         return retval;
 324 }
 325
 326 /* Open dir/Help, or show a message if missing */
 327 void show_help_files(const char *dir)
 328 {
 329         const char      *help_dir;
 330
 331         help_dir = make_path(dir, "Help");
 332
 333         if (file_exists(help_dir))
 334                 filer_opendir(help_dir, NULL, NULL);
 335         else
 336                 info_message(
 337                         _("Application:\n"
 338                         "This is an application directory - you can "
 339                         "run it as a program, or open it (hold down "
 340                         "Shift while you open it). Most applications provide "
 341                         "their own help here, but this one doesn't."));
 342 }
 343
 344 /* Open a directory viewer showing this file, and wink it */
 345 void open_to_show(const guchar *path)
 346 {
 347         FilerWindow     *new;
 348         guchar          *dir, *slash;
 349
 350         g_return_if_fail(path != NULL);
 351
 352         dir = g_strdup(path);
 353         slash = strrchr(dir, '/');
 354         if (slash == dir || !slash)
 355         {
 356                 /* Item in the root (or root itself!) */
 357                 new = filer_opendir("/", NULL, NULL);
 358                 if (new && dir[1])
 359                         display_set_autoselect(new, dir + 1);
 360         }
 361         else
 362         {
 363                 *slash = '\0';
 364                 new = filer_opendir(dir, NULL, NULL);
 365                 if (new)
 366                 {
 367                         if (slash[1] == '.')
 368                                 display_set_hidden(new, TRUE);
 369                         display_set_autoselect(new, slash + 1);
 370                 }
 371         }
 372
 373         g_free(dir);
 374 }
 375
 376 /* Invoked using -x, this indicates that the filesystem has been modified
 377  * and we should look at this item again.
 378  */
 379 void examine(const guchar *path)
 380 {
 381         struct stat info;
 382
 383         if (mc_stat(path, &info) != 0)
 384         {
 385                 /* Deleted? Do a paranoid update of everything... */
 386                 filer_check_mounted(path);
 387         }
 388         else
 389         {
 390                 /* Update directory containing this item... */
 391                 dir_check_this(path);
 392
 393                 /* If this is itself a directory then rescan its contents... */
 394                 if (S_ISDIR(info.st_mode))
 395                         refresh_dirs(path);
 396
 397                 /* If it's on the pinboard or a panel, update the icon... */
 398                 icons_may_update(path);
 399         }
 400 }
 401
 402 /****************************************************************
 403  *                      INTERNAL FUNCTIONS                      *
 404  ****************************************************************/
 405
 406
 407 static void write_data(gpointer data, gint fd, GdkInputCondition cond)
 408 {
 409         PipedData *pd = (PipedData *) data;
 410
 411         while (pd->sent < pd->length)
 412         {
 413                 int     sent;
 414
 415                 sent = write(fd, pd->data + pd->sent, pd->length - pd->sent);
 416
 417                 if (sent < 0)
 418                 {
 419                         if (errno == EAGAIN)
 420                                 return;
 421                         delayed_error(_("Could not send data to program: %s"),
 422                                         g_strerror(errno));
 423                         goto finish;
 424                 }
 425
 426                 pd->sent += sent;
 427         }
 428
 429 finish:
 430         g_source_remove(pd->tag);
 431         g_free(pd->data);
 432         g_free(pd);
 433         close(fd);
 434 }
 435
 436 /* Follow the link 'full_path' and display it in filer_window, or a
 437  * new window if that is NULL.
 438  */
 439 static gboolean follow_symlink(const char *full_path,
 440                                FilerWindow *filer_window,
 441                                FilerWindow *src_window)
 442 {
 443         char    *real, *slash;
 444         char    *new_dir;
 445         char    path[MAXPATHLEN + 1];
 446         int     got;
 447
 448         got = readlink(full_path, path, MAXPATHLEN);
 449         if (got < 0)
 450         {
 451                 delayed_error(_("Could not read link: %s"),
 452                                   g_strerror(errno));
 453                 return FALSE;
 454         }
 455
 456         g_return_val_if_fail(got <= MAXPATHLEN, FALSE);
 457         path[got] = '\0';
 458
 459         /* Make a relative path absolute */
 460         if (path[0] != '/')
 461         {
 462                 guchar  *tmp;
 463                 slash = strrchr(full_path, '/');
 464                 g_return_val_if_fail(slash != NULL, FALSE);
 465
 466                 tmp = g_strndup(full_path, slash - full_path);
 467                 real = pathdup(make_path(tmp, path));
 468                 /* NB: full_path may be invalid here... */
 469                 g_free(tmp);
 470         }
 471         else
 472                 real = pathdup(path);
 473
 474         slash = strrchr(real, '/');
 475         if (!slash)
 476         {
 477                 g_free(real);
 478                 delayed_error(
 479                         _("Broken symlink (or you don't have permission "
 480                           "to follow it): %s"), full_path);
 481                 return FALSE;
 482         }
 483
 484         *slash = '\0';
 485
 486         if (*real)
 487                 new_dir = real;
 488         else
 489                 new_dir = "/";
 490
 491         if (filer_window)
 492                 filer_change_to(filer_window, new_dir, slash + 1);
 493         else
 494         {
 495                 FilerWindow *new;
 496
 497                 new = filer_opendir(new_dir, src_window, NULL);
 498                 if (new)
 499                         display_set_autoselect(new, slash + 1);
 500         }
 501
 502         g_free(real);
 503
 504         return TRUE;
 505 }
 506
 507 /* Load this file into an appropriate editor */
 508 static gboolean open_file(const guchar *path, MIME_type *type)
 509 {
 510         g_return_val_if_fail(type != NULL, FALSE);
 511
 512         if (type_open(path, type))
 513                 return TRUE;
 514
 515         report_error(
 516                 _("No run action specified for files of this type (%s/%s) - "
 517                 "you can set a run action by choosing `Set Run Action' "
 518                 "from the File menu, or you can just drag the file to an "
 519                 "application.%s"),
 520                 type->media_type,
 521                 type->subtype,
 522                 type->executable ? _("\n\nNote: If this is a computer program which "
 523                                    "you want to run, you need to set the execute bit "
 524                                    "by choosing Permissions from the File menu.")
 525                                 : "");
 526
 527         return FALSE;
 528 }
 529
 530 /* Called like run_diritem, when a mount-point is opened */
 531 static void open_mountpoint(const guchar *full_path, DirItem *item,
 532                             FilerWindow *filer_window, FilerWindow *src_window,
 533                             gboolean edit)
 534 {
 535         gboolean mounted = (item->flags & ITEM_FLAG_MOUNTED) != 0;
 536
 537         if (mounted == edit)
 538         {
 539                 GList   *paths;
 540
 541                 paths = g_list_prepend(NULL, (gpointer) full_path);
 542                 action_mount(paths, filer_window == NULL, !mounted, -1);
 543                 g_list_free(paths);
 544                 if (filer_window && !mounted)
 545                         filer_change_to(filer_window, full_path, NULL);
 546         }
 547         else
 548         {
 549                 if (filer_window)
 550                         filer_change_to(filer_window, full_path, NULL);
 551                 else
 552                         filer_opendir(full_path, src_window, NULL);
 553         }
 554 }
 555
 556 /* full_path is a .desktop file. Execute the application, using the Exec line
 557  * from the file.
 558  * Returns TRUE on success.
 559  */
 560 static gboolean run_desktop(const char *full_path,
 561                             const char **args,
 562                             const char *dir)
 563 {
 564         GError *error = NULL;
 565         char *exec = NULL;
 566         gint argc = 0;
 567         gchar **argv = NULL;
 568         GPtrArray *expanded = NULL;
 569         gboolean inserted_args = FALSE;
 570         int i;
 571         gboolean success = FALSE;
 572
 573         exec = get_value_from_desktop_file(full_path, "Desktop Entry", "Exec",
 574                                         &error);
 575         if (error)
 576         {
 577                 delayed_error("Failed to parse .desktop file '%s':\n%s",
 578                                 full_path, error->message);
 579                 goto err;
 580         }
 581
 582         if (!exec)
 583         {
 584                 delayed_error("Can't find Exec command in .desktop file '%s'",
 585                                 full_path);
 586                 goto err;
 587         }
 588
 589         if (!g_shell_parse_argv(exec, &argc, &argv, &error))
 590         {
 591                 delayed_error("Failed to parse '%s' from '%s':\n%s",
 592                                 exec, full_path, error->message);
 593                 goto err;
 594         }
 595
 596         expanded = g_ptr_array_new();
 597         for (i = 0; i < argc; i++)
 598         {
 599                 const char *src = argv[i];
 600
 601                 if (src[0] == '%' && src[1] != '\0' && src[2] == '\0')
 602                 {
 603                         /* We should treat these four differently. */
 604                         if (src[1] == 'f' || src[1] == 'F' ||
 605                             src[1] == 'u' || src[1] == 'U')
 606                         {
 607                                 int j;
 608                                 for (j = 0; args && args[j]; j++)
 609                                         g_ptr_array_add(expanded, g_strdup(args[j]));
 610                                 inserted_args = TRUE;
 611                         }
 612                         else
 613                         {
 614                                 delayed_error("Unsupported escape character in '%s' in '%s'",
 615                                                 exec, full_path);
 616                                 goto err;
 617                         }
 618                 }
 619                 else
 620                 {
 621                         g_ptr_array_add(expanded, g_strdup(src));
 622                 }
 623         }
 624         if (!inserted_args)
 625         {
 626                 /* Many .desktop files don't include a % expansion. In that case
 627                  * add the arguments here.
 628                  */
 629                 int j;
 630                 for (j = 0; args && args[j]; j++)
 631                         g_ptr_array_add(expanded, g_strdup(args[j]));
 632         }
 633         g_ptr_array_add(expanded, NULL);
 634
 635         success = rox_spawn(dir, (const gchar **) expanded->pdata);
 636 err:
 637         if (error != NULL)
 638                 g_error_free(error);
 639         if (exec != NULL)
 640                 g_free(exec);
 641         if (argv != NULL)
 642                 g_strfreev(argv);
 643         if (expanded != NULL)
 644         {
 645                 g_ptr_array_foreach(expanded, (GFunc) g_free, NULL);
 646                 g_ptr_array_free(expanded, TRUE);
 647         }
 648
 649         return success;
 650 }
 651
 652 /* Returns FALSE is no run action is set for this type. */
 653 static gboolean type_open(const char *path, MIME_type *type)
 654 {
 655         gchar *argv[] = {NULL, NULL, NULL};
 656         char            *open;
 657         struct stat     info;
 658
 659         argv[1] = (char *) path;
 660
 661         open = handler_for(type);
 662         if (!open)
 663                 return FALSE;
 664
 665         if (stat(open, &info))
 666         {
 667                 report_error("stat(%s): %s", open, g_strerror(errno));
 668                 g_free(open);
 669                 return TRUE;
 670         }
 671
 672         if (info.st_mode & S_IWOTH)
 673         {
 674                 gchar *choices_dir;
 675                 GList *paths;
 676
 677                 report_error(_("Executable '%s' is world-writeable! Refusing "
 678                         "to run. Please change the permissions now (this "
 679                         "problem may have been caused by a bug in earlier "
 680                         "versions of the filer).\n\n"
 681                         "Having (non-symlink) run actions world-writeable "
 682                         "means that other people who use your computer can "
 683                         "replace your run actions with malicious versions.\n\n"
 684                         "If you trust everyone who could write to these files "
 685                         "then you needn't worry. Otherwise, you should check, "
 686                         "or even just delete, all the existing run actions."),
 687                         open);
 688                 choices_dir = g_path_get_dirname(open);
 689                 paths = g_list_append(NULL, choices_dir);
 690                 action_chmod(paths, TRUE, _("go-w (Fix security problem)"));
 691                 g_free(choices_dir);
 692                 g_list_free(paths);
 693                 g_free(open);
 694                 return TRUE;
 695         }
 696
 697         if (S_ISDIR(info.st_mode))
 698         {
 699                 argv[0] = g_strconcat(open, "/AppRun", NULL);
 700                 rox_spawn(home_dir, (const gchar **) argv);
 701         }
 702         else if (type_get_type(open) == application_x_desktop)
 703         {
 704                 argv[0] = open;
 705                 run_desktop(open, (const char **) (argv + 1), home_dir);
 706         }
 707         else
 708         {
 709                 argv[0] = open;
 710                 rox_spawn(home_dir, (const gchar **) argv);
 711         }
 712
 713         if (argv[0] != open)
 714                 g_free(argv[0]);
 715
 716         g_free(open);
 717
 718         return TRUE;
 719 }
 720