ROX-Filer/src/run.c

   1 /*
   2  * $Id$
   3  *
   4  * ROX-Filer, filer for the ROX desktop project
   5  * Copyright (C) 2003, the ROX-Filer team.
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the Free
   9  * Software Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15  * more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along with
  18  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  19  * Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 /* run.c */
  23
  24 #include "config.h"
  25
  26 #include <errno.h>
  27 #include <string.h>
  28 #include <sys/param.h>
  29
  30 #include "global.h"
  31
  32 #include "run.h"
  33 #include "support.h"
  34 #include "gui_support.h"
  35 #include "filer.h"
  36 #include "display.h"
  37 #include "main.h"
  38 #include "type.h"
  39 #include "dir.h"
  40 #include "diritem.h"
  41 #include "action.h"
  42 #include "icon.h"
  43
  44 /* Static prototypes */
  45 static void write_data(gpointer data, gint fd, GdkInputCondition cond);
  46 static gboolean follow_symlink(const char *full_path,
  47                                FilerWindow *filer_window,
  48                                FilerWindow *src_window);
  49 static gboolean open_file(const guchar *path, MIME_type *type);
  50 static void open_mountpoint(const guchar *full_path, DirItem *item,
  51                             FilerWindow *filer_window, FilerWindow *src_window,
  52                             gboolean edit);
  53
  54 typedef struct _PipedData PipedData;
  55
  56 struct _PipedData
  57 {
  58         guchar          *data;
  59         gint            tag;
  60         gulong          sent;
  61         gulong          length;
  62 };
  63
  64
  65 /****************************************************************
  66  *                      EXTERNAL INTERFACE                      *
  67  ****************************************************************/
  68
  69
  70 /* An application has been double-clicked (or run in some other way) */
  71 void run_app(const char *path)
  72 {
  73         GString *apprun;
  74         const char *argv[] = {NULL, NULL};
  75
  76         apprun = g_string_new(path);
  77         argv[0] = g_string_append(apprun, "/AppRun")->str;
  78
  79         rox_spawn(home_dir, argv);
  80
  81         g_string_free(apprun, TRUE);
  82 }
  83
  84 /* Execute this program, passing all the URIs in the list as arguments.
  85  * URIs that are files on the local machine will be passed as simple
  86  * pathnames. The uri_list should be freed after this function returns.
  87  */
  88 void run_with_files(const char *path, GList *uri_list)
  89 {
  90         const char      **argv;
  91         int             argc = 0;
  92         struct stat     info;
  93
  94         if (stat(path, &info))
  95         {
  96                 delayed_error(_("Program %s not found - deleted?"), path);
  97                 return;
  98         }
  99
 100         argv = g_malloc(sizeof(char *) * (g_list_length(uri_list) + 2));
 101
 102         if (S_ISDIR(info.st_mode))
 103                 argv[argc++] = make_path(path, "AppRun");
 104         else
 105                 argv[argc++] = path;
 106
 107         while (uri_list)
 108         {
 109                 const char *uri = uri_list->data;
 110                 const char *local;
 111
 112                 local = get_local_path(uri);
 113                 if (local)
 114                         argv[argc++] = local;
 115                 else
 116                         argv[argc++] = uri;
 117                 uri_list = uri_list->next;
 118         }
 119
 120         argv[argc++] = NULL;
 121
 122         rox_spawn(home_dir, argv);
 123 }
 124
 125 /* Run the program as '<path> -', piping the data to it via stdin.
 126  * You can g_free() the data as soon as this returns.
 127  */
 128 void run_with_data(const char *path, gpointer data, gulong length)
 129 {
 130         const char      *argv[] = {NULL, "-", NULL};
 131         struct stat     info;
 132         int             fds[2];
 133         PipedData       *pd;
 134
 135         if (stat(path, &info))
 136         {
 137                 delayed_error(_("Program %s not found - deleted?"), path);
 138                 return;
 139         }
 140
 141         if (S_ISDIR(info.st_mode))
 142                 argv[0] = make_path(path, "AppRun");
 143         else
 144                 argv[0] = path;
 145
 146         if (pipe(fds))
 147         {
 148                 delayed_error("pipe: %s", g_strerror(errno));
 149                 return;
 150         }
 151         close_on_exec(fds[1], TRUE);
 152         close_on_exec(fds[0], TRUE);
 153
 154         switch (fork())
 155         {
 156                 case -1:
 157                         delayed_error("fork: %s", g_strerror(errno));
 158                         close(fds[1]);
 159                         break;
 160                 case 0:
 161                         /* We are the child */
 162                         chdir(home_dir);
 163                         if (dup2(fds[0], 0) == -1)
 164                                 g_warning("dup2() failed: %s\n",
 165                                                 g_strerror(errno));
 166                         else
 167                         {
 168                                 close_on_exec(0, FALSE);
 169                                 if (execv(argv[0], (char **) argv))
 170                                         g_warning("execv(%s) failed: %s\n",
 171                                                 argv[0], g_strerror(errno));
 172                         }
 173                         _exit(1);
 174                 default:
 175                         /* We are the parent */
 176                         set_blocking(fds[1], FALSE);
 177                         pd = g_new(PipedData, 1);
 178                         pd->data = g_malloc(length);
 179                         memcpy(pd->data, data, length);
 180                         pd->length = length;
 181                         pd->sent = 0;
 182                         pd->tag = gtk_input_add_full(fds[1], GDK_INPUT_WRITE,
 183                                                 write_data, NULL, pd, NULL);
 184                         break;
 185         }
 186
 187         close(fds[0]);
 188 }
 189
 190 /* Load a file, open a directory or run an application. Or, if 'edit' is set:
 191  * edit a file, open an application, follow a symlink or mount a device.
 192  *
 193  * filer_window is the window to use for displaying a directory.
 194  * NULL will always use a new directory when needed.
 195  * src_window is the window to copy options from, or NULL.
 196  *
 197  * Returns TRUE on success.
 198  */
 199 gboolean run_diritem(const guchar *full_path,
 200                      DirItem *item,
 201                      FilerWindow *filer_window,
 202                      FilerWindow *src_window,
 203                      gboolean edit)
 204 {
 205         if (item->flags & ITEM_FLAG_SYMLINK && edit)
 206                 return follow_symlink(full_path, filer_window, src_window);
 207
 208         switch (item->base_type)
 209         {
 210                 case TYPE_DIRECTORY:
 211                         if (item->flags & ITEM_FLAG_APPDIR && !edit)
 212                         {
 213                                 run_app(full_path);
 214                                 return TRUE;
 215                         }
 216
 217                         if (item->flags & ITEM_FLAG_MOUNT_POINT)
 218                         {
 219                                 open_mountpoint(full_path, item,
 220                                                 filer_window, src_window, edit);
 221                         }
 222                         else if (filer_window)
 223                                 filer_change_to(filer_window, full_path, NULL);
 224                         else
 225                                 filer_opendir(full_path, src_window, NULL);
 226                         return TRUE;
 227                 case TYPE_FILE:
 228                         if (item->mime_type == application_executable && !edit)
 229                         {
 230                                 const char *argv[] = {NULL, NULL};
 231                                 guchar  *dir = filer_window
 232                                                 ? filer_window->sym_path
 233                                                 : NULL;
 234
 235                                 argv[0] = full_path;
 236
 237                                 return rox_spawn(dir, argv) != 0;
 238                         }
 239
 240                         return open_file(full_path, edit ? text_plain
 241                                                   : item->mime_type);
 242                 case TYPE_ERROR:
 243                         delayed_error(_("File doesn't exist, or I can't "
 244                                           "access it: %s"), full_path);
 245                         return FALSE;
 246                 default:
 247                         delayed_error(
 248                                 _("I don't know how to open '%s'"), full_path);
 249                         return FALSE;
 250         }
 251 }
 252
 253 /* Attempt to open this item */
 254 gboolean run_by_path(const guchar *full_path)
 255 {
 256         gboolean retval;
 257         DirItem *item;
 258
 259         /* XXX: Loads an image - wasteful */
 260         item = diritem_new("");
 261         diritem_restat(full_path, item, NULL);
 262         retval = run_diritem(full_path, item, NULL, NULL, FALSE);
 263         diritem_free(item);
 264
 265         return retval;
 266 }
 267
 268 /* Open dir/Help, or show a message if missing */
 269 void show_help_files(const char *dir)
 270 {
 271         const char      *help_dir;
 272
 273         help_dir = make_path(dir, "Help");
 274
 275         if (file_exists(help_dir))
 276                 filer_opendir(help_dir, NULL, NULL);
 277         else
 278                 info_message(
 279                         _("Application:\n"
 280                         "This is an application directory - you can "
 281                         "run it as a program, or open it (hold down "
 282                         "Shift while you open it). Most applications provide "
 283                         "their own help here, but this one doesn't."));
 284 }
 285
 286 /* Open a directory viewer showing this file, and wink it */
 287 void open_to_show(const guchar *path)
 288 {
 289         FilerWindow     *new;
 290         guchar          *dir, *slash;
 291
 292         g_return_if_fail(path != NULL);
 293
 294         dir = g_strdup(path);
 295         slash = strrchr(dir, '/');
 296         if (slash == dir || !slash)
 297         {
 298                 /* Item in the root (or root itself!) */
 299                 new = filer_opendir("/", NULL, NULL);
 300                 if (new && dir[1])
 301                         display_set_autoselect(new, dir + 1);
 302         }
 303         else
 304         {
 305                 *slash = '\0';
 306                 new = filer_opendir(dir, NULL, NULL);
 307                 if (new)
 308                 {
 309                         if (slash[1] == '.')
 310                                 display_set_hidden(new, TRUE);
 311                         display_set_autoselect(new, slash + 1);
 312                 }
 313         }
 314
 315         g_free(dir);
 316 }
 317
 318 /* Invoked using -x, this indicates that the filesystem has been modified
 319  * and we should look at this item again.
 320  */
 321 void examine(const guchar *path)
 322 {
 323         struct stat info;
 324
 325         if (mc_stat(path, &info) != 0)
 326         {
 327                 /* Deleted? Do a paranoid update of everything... */
 328                 filer_check_mounted(path);
 329         }
 330         else
 331         {
 332                 /* Update directory containing this item... */
 333                 dir_check_this(path);
 334
 335                 /* If this is itself a directory then rescan its contents... */
 336                 if (S_ISDIR(info.st_mode))
 337                         refresh_dirs(path);
 338
 339                 /* If it's on the pinboard, update the icon... */
 340                 icons_may_update(path);
 341         }
 342 }
 343
 344 /****************************************************************
 345  *                      INTERNAL FUNCTIONS                      *
 346  ****************************************************************/
 347
 348
 349 static void write_data(gpointer data, gint fd, GdkInputCondition cond)
 350 {
 351         PipedData *pd = (PipedData *) data;
 352
 353         while (pd->sent < pd->length)
 354         {
 355                 int     sent;
 356
 357                 sent = write(fd, pd->data + pd->sent, pd->length - pd->sent);
 358
 359                 if (sent < 0)
 360                 {
 361                         if (errno == EAGAIN)
 362                                 return;
 363                         delayed_error(_("Could not send data to program: %s"),
 364                                         g_strerror(errno));
 365                         goto finish;
 366                 }
 367
 368                 pd->sent += sent;
 369         }
 370
 371 finish:
 372         g_source_remove(pd->tag);
 373         g_free(pd->data);
 374         g_free(pd);
 375         close(fd);
 376 }
 377
 378 /* Follow the link 'full_path' and display it in filer_window, or a
 379  * new window if that is NULL.
 380  */
 381 static gboolean follow_symlink(const char *full_path,
 382                                FilerWindow *filer_window,
 383                                FilerWindow *src_window)
 384 {
 385         char    *real, *slash;
 386         char    *new_dir;
 387         char    path[MAXPATHLEN + 1];
 388         int     got;
 389
 390         got = readlink(full_path, path, MAXPATHLEN);
 391         if (got < 0)
 392         {
 393                 delayed_error(_("Could not read link: %s"),
 394                                   g_strerror(errno));
 395                 return FALSE;
 396         }
 397
 398         g_return_val_if_fail(got <= MAXPATHLEN, FALSE);
 399         path[got] = '\0';
 400
 401         /* Make a relative path absolute */
 402         if (path[0] != '/')
 403         {
 404                 guchar  *tmp;
 405                 slash = strrchr(full_path, '/');
 406                 g_return_val_if_fail(slash != NULL, FALSE);
 407
 408                 tmp = g_strndup(full_path, slash - full_path);
 409                 real = pathdup(make_path(tmp, path));
 410                 /* NB: full_path may be invalid here... */
 411                 g_free(tmp);
 412         }
 413         else
 414                 real = pathdup(path);
 415
 416         slash = strrchr(real, '/');
 417         if (!slash)
 418         {
 419                 g_free(real);
 420                 delayed_error(
 421                         _("Broken symlink (or you don't have permission "
 422                           "to follow it): %s"), full_path);
 423                 return FALSE;
 424         }
 425
 426         *slash = '\0';
 427
 428         if (*real)
 429                 new_dir = real;
 430         else
 431                 new_dir = "/";
 432
 433         if (filer_window)
 434                 filer_change_to(filer_window, new_dir, slash + 1);
 435         else
 436         {
 437                 FilerWindow *new;
 438
 439                 new = filer_opendir(new_dir, src_window, NULL);
 440                 if (new)
 441                         display_set_autoselect(new, slash + 1);
 442         }
 443
 444         g_free(real);
 445
 446         return TRUE;
 447 }
 448
 449 /* Load this file into an appropriate editor */
 450 static gboolean open_file(const guchar *path, MIME_type *type)
 451 {
 452         g_return_val_if_fail(type != NULL, FALSE);
 453
 454         if (type_open(path, type))
 455                 return TRUE;
 456
 457         report_error(
 458                 _("No run action specified for files of this type (%s/%s) - "
 459                 "you can set a run action by choosing `Set Run Action' "
 460                 "from the File menu, or you can just drag the file to an "
 461                 "application"),
 462                 type->media_type,
 463                 type->subtype);
 464
 465         return FALSE;
 466 }
 467
 468 /* Called like run_diritem, when a mount-point is opened */
 469 static void open_mountpoint(const guchar *full_path, DirItem *item,
 470                             FilerWindow *filer_window, FilerWindow *src_window,
 471                             gboolean edit)
 472 {
 473         gboolean mounted = (item->flags & ITEM_FLAG_MOUNTED) != 0;
 474
 475         if (mounted == edit)
 476         {
 477                 GList   *paths;
 478
 479                 paths = g_list_prepend(NULL, (gpointer) full_path);
 480                 action_mount(paths, filer_window == NULL, -1);
 481                 g_list_free(paths);
 482                 if (filer_window && !mounted)
 483                         filer_change_to(filer_window, full_path, NULL);
 484         }
 485         else
 486         {
 487                 if (filer_window)
 488                         filer_change_to(filer_window, full_path, NULL);
 489                 else
 490                         filer_opendir(full_path, src_window, NULL);
 491         }
 492 }