lib/rb-file-helpers.c

   1 /*
   2  *  arch-tag: Implementation of various Rhythmbox utility functions for URIs and files
   3  *
   4  *  Copyright (C) 2002 Jorn Baayen
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2, or (at your option)
   9  *  any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA.
  19  *
  20  */
  21
  22 #include <gtk/gtk.h>
  23 #include <glib.h>
  24 #include <stdio.h>
  25 #include <string.h>
  26 #include <config.h>
  27 #include <libgnome/gnome-i18n.h>
  28 #include <libgnome/gnome-init.h>
  29 #include <libgnomevfs/gnome-vfs-utils.h>
  30 #include <libgnomevfs/gnome-vfs-file-info.h>
  31 #include <libgnomevfs/gnome-vfs-ops.h>
  32 #include <libgnomevfs/gnome-vfs-directory.h>
  33 #include <unistd.h>
  34
  35 #include "rb-file-helpers.h"
  36 #include "rb-debug.h"
  37
  38 static GHashTable *files = NULL;
  39
  40 static char *dot_dir = NULL;
  41
  42 const char *
  43 rb_file (const char *filename)
  44 {
  45         char *ret;
  46         int i;
  47
  48         static char *paths[] = {
  49 #ifdef SHARE_UNINSTALLED_DIR
  50                 SHARE_UNINSTALLED_DIR "/",
  51                 SHARE_UNINSTALLED_DIR "/ui/",
  52                 SHARE_UNINSTALLED_DIR "/glade/",
  53                 SHARE_UNINSTALLED_DIR "/art/",
  54 #endif
  55                 SHARE_DIR "/",
  56                 SHARE_DIR "/glade/",
  57                 SHARE_DIR "/art/",
  58         };
  59
  60         g_assert (files != NULL);
  61
  62         ret = g_hash_table_lookup (files, filename);
  63         if (ret != NULL)
  64                 return ret;
  65
  66         for (i = 0; i < (int) G_N_ELEMENTS (paths); i++) {
  67                 ret = g_strconcat (paths[i], filename, NULL);
  68                 if (g_file_test (ret, G_FILE_TEST_EXISTS) == TRUE) {
  69                         g_hash_table_insert (files, g_strdup (filename), ret);
  70                         return (const char *) ret;
  71                 }
  72                 g_free (ret);
  73         }
  74
  75         return NULL;
  76 }
  77
  78 const char *
  79 rb_dot_dir (void)
  80 {
  81         if (dot_dir == NULL) {
  82                 dot_dir = g_build_filename (g_get_home_dir (),
  83                                             GNOME_DOT_GNOME,
  84                                             "rhythmbox",
  85                                             NULL);
  86                 if (mkdir (dot_dir, 0750) == -1)
  87                         rb_debug ("unable to create Rhythmbox's dot dir");
  88         }
  89
  90         return dot_dir;
  91 }
  92
  93 void
  94 rb_file_helpers_init (void)
  95 {
  96         files = g_hash_table_new_full (g_str_hash,
  97                                        g_str_equal,
  98                                        (GDestroyNotify) g_free,
  99                                        (GDestroyNotify) g_free);
 100 }
 101
 102 void
 103 rb_file_helpers_shutdown (void)
 104 {
 105         g_hash_table_destroy (files);
 106
 107         g_free (dot_dir);
 108 }
 109
 110 #define MAX_LINK_LEVEL 5
 111
 112 char *
 113 rb_uri_resolve_symlink (const char *uri)
 114 {
 115         gint link_count;
 116         GnomeVFSFileInfo *info;
 117         char *followed;
 118
 119         g_return_val_if_fail (uri != NULL, NULL);
 120
 121         info = gnome_vfs_file_info_new ();
 122         gnome_vfs_get_file_info (uri, info, GNOME_VFS_FILE_INFO_DEFAULT);
 123
 124         if (info->type != GNOME_VFS_FILE_TYPE_SYMBOLIC_LINK) {
 125                 gnome_vfs_file_info_unref (info);
 126                 return g_strdup (uri);
 127         }
 128
 129         link_count = 0;
 130         followed = g_strdup (uri);
 131         while (link_count < MAX_LINK_LEVEL) {
 132                 GnomeVFSURI *vfs_uri;
 133                 GnomeVFSURI *new_vfs_uri;
 134                 char *escaped_path;
 135
 136                 vfs_uri = gnome_vfs_uri_new (followed);
 137                 escaped_path = gnome_vfs_escape_path_string (info->symlink_name);
 138                 new_vfs_uri = gnome_vfs_uri_resolve_relative (vfs_uri,
 139                                                               escaped_path);
 140                 g_free (escaped_path);
 141
 142                 g_free (followed);
 143                 followed = gnome_vfs_uri_to_string (new_vfs_uri,
 144                                                     GNOME_VFS_URI_HIDE_NONE);
 145                 link_count++;
 146
 147                 gnome_vfs_uri_unref (new_vfs_uri);
 148                 gnome_vfs_uri_unref (vfs_uri);
 149
 150                 gnome_vfs_file_info_clear (info);
 151                 gnome_vfs_get_file_info (followed, info,
 152                                          GNOME_VFS_FILE_INFO_DEFAULT);
 153
 154                 if (info->type != GNOME_VFS_FILE_TYPE_SYMBOLIC_LINK) {
 155                         gnome_vfs_file_info_unref (info);
 156                         return followed;
 157                 }
 158         }
 159
 160         /* Too many symlinks */
 161
 162         gnome_vfs_file_info_unref (info);
 163
 164         return NULL;
 165 }
 166
 167 gboolean
 168 rb_uri_is_directory (const char *uri)
 169 {
 170         GnomeVFSFileInfo *info;
 171         gboolean dir;
 172
 173         g_return_val_if_fail (uri != NULL, FALSE);
 174
 175         info = gnome_vfs_file_info_new ();
 176
 177         gnome_vfs_get_file_info (uri, info,
 178                                  GNOME_VFS_FILE_INFO_FORCE_FAST_MIME_TYPE |
 179                                  GNOME_VFS_FILE_INFO_FOLLOW_LINKS);
 180
 181         if (info->type == GNOME_VFS_FILE_TYPE_DIRECTORY)
 182                 dir = TRUE;
 183         else
 184                 dir = FALSE;
 185
 186         gnome_vfs_file_info_unref (info);
 187
 188         return dir;
 189 }
 190
 191 gboolean
 192 rb_uri_exists (const char *uri)
 193 {
 194         GnomeVFSURI *vuri;
 195         gboolean ret;
 196
 197         g_return_val_if_fail (uri != NULL, FALSE);
 198
 199         vuri = gnome_vfs_uri_new (uri);
 200         ret = gnome_vfs_uri_exists (vuri);
 201         gnome_vfs_uri_unref (vuri);
 202
 203         return ret;
 204 }
 205
 206 static gboolean
 207 is_valid_scheme_character (char c)
 208 {
 209         return g_ascii_isalnum (c) || c == '+' || c == '-' || c == '.';
 210 }
 211
 212 /*
 213  * FIXME this is not the simplest or most time-efficent way
 214  * to do this.  Probably a far more clear way of doing this processing
 215  * is to split the path into segments, rather than doing the processing
 216  * in place.
 217  */
 218 static void
 219 remove_internal_relative_components (char *uri_current)
 220 {
 221         char *segment_prev, *segment_cur;
 222         size_t len_prev, len_cur;
 223
 224         len_prev = len_cur = 0;
 225         segment_prev = NULL;
 226
 227         g_return_if_fail (uri_current != NULL);
 228
 229         segment_cur = uri_current;
 230
 231         while (*segment_cur) {
 232                 len_cur = strcspn (segment_cur, "/");
 233
 234                 if (len_cur == 1 && segment_cur[0] == '.') {
 235                         /* Remove "." 's */
 236                         if (segment_cur[1] == '\0') {
 237                                 segment_cur[0] = '\0';
 238                                 break;
 239                         } else {
 240                                 memmove (segment_cur, segment_cur + 2, strlen (segment_cur + 2) + 1);
 241                                 continue;
 242                         }
 243                 } else if (len_cur == 2 && segment_cur[0] == '.' && segment_cur[1] == '.' ) {
 244                         /* Remove ".."'s (and the component to the left of it) that aren't at the
 245                          * beginning or to the right of other ..'s
 246                          */
 247                         if (segment_prev) {
 248                                 if (! (len_prev == 2
 249                                        && segment_prev[0] == '.'
 250                                        && segment_prev[1] == '.')) {
 251                                         if (segment_cur[2] == '\0') {
 252                                                 segment_prev[0] = '\0';
 253                                                 break;
 254                                         } else {
 255                                                 memmove (segment_prev, segment_cur + 3, strlen (segment_cur + 3) + 1);
 256
 257                                                 segment_cur = segment_prev;
 258                                                 len_cur = len_prev;
 259
 260                                                 /* now we find the previous segment_prev */
 261                                                 if (segment_prev == uri_current) {
 262                                                         segment_prev = NULL;
 263                                                 } else if (segment_prev - uri_current >= 2) {
 264                                                         segment_prev -= 2;
 265                                                         for ( ; segment_prev > uri_current && segment_prev[0] != '/'
 266                                                               ; segment_prev-- );
 267                                                         if (segment_prev[0] == '/') {
 268                                                                 segment_prev++;
 269                                                         }
 270                                                 }
 271                                                 continue;
 272                                         }
 273                                 }
 274                         }
 275                 }
 276
 277                 /*Forward to next segment */
 278
 279                 if (segment_cur [len_cur] == '\0') {
 280                         break;
 281                 }
 282
 283                 segment_prev = segment_cur;
 284                 len_prev = len_cur;
 285                 segment_cur += len_cur + 1;
 286         }
 287 }
 288
 289 static gboolean
 290 is_uri_partial (const char *uri)
 291 {
 292         const char *current;
 293
 294         /* RFC 2396 section 3.1 */
 295         for (current = uri ;
 296                 *current
 297                 &&      ((*current >= 'a' && *current <= 'z')
 298                          || (*current >= 'A' && *current <= 'Z')
 299                          || (*current >= '0' && *current <= '9')
 300                          || ('-' == *current)
 301                          || ('+' == *current)
 302                          || ('.' == *current)) ;
 303                 current++);
 304
 305         return  !(':' == *current);
 306 }
 307
 308 /**
 309  * eel_uri_make_full_from_relative:
 310  *
 311  * Returns a full URI given a full base URI, and a secondary URI which may
 312  * be relative.
 313  *
 314  * Return value: the URI (NULL for some bad errors).
 315  *
 316  * FIXME: This code has been copied from eel-mozilla-content-view
 317  * because eel-mozilla-content-view cannot link with libeel-extensions
 318  * due to lame license issues.  Really, this belongs in gnome-vfs, but was added
 319  * after the Gnome 1.4 gnome-vfs API freeze
 320  **/
 321
 322 static char *
 323 eel_uri_make_full_from_relative (const char *base_uri, const char *relative_uri)
 324 {
 325         char *result = NULL;
 326
 327         /* See section 5.2 in RFC 2396 */
 328
 329         if (base_uri == NULL && relative_uri == NULL) {
 330                 result = NULL;
 331         } else if (base_uri == NULL) {
 332                 result = g_strdup (relative_uri);
 333         } else if (relative_uri == NULL) {
 334                 result = g_strdup (base_uri);
 335         } else if (!is_uri_partial (relative_uri)) {
 336                 result = g_strdup (relative_uri);
 337         } else {
 338                 char *mutable_base_uri;
 339                 char *mutable_uri;
 340
 341                 char *uri_current;
 342                 size_t base_uri_length;
 343                 char *separator;
 344
 345                 mutable_base_uri = g_strdup (base_uri);
 346                 uri_current = mutable_uri = g_strdup (relative_uri);
 347
 348                 /* Chew off Fragment and Query from the base_url */
 349
 350                 separator = strrchr (mutable_base_uri, '#');
 351
 352                 if (separator) {
 353                         *separator = '\0';
 354                 }
 355
 356                 separator = strrchr (mutable_base_uri, '?');
 357
 358                 if (separator) {
 359                         *separator = '\0';
 360                 }
 361
 362                 if ('/' == uri_current[0] && '/' == uri_current [1]) {
 363                         /* Relative URI's beginning with the authority
 364                          * component inherit only the scheme from their parents
 365                          */
 366
 367                         separator = strchr (mutable_base_uri, ':');
 368
 369                         if (separator) {
 370                                 separator[1] = '\0';
 371                         }
 372                 } else if ('/' == uri_current[0]) {
 373                         /* Relative URI's beginning with '/' absolute-path based
 374                          * at the root of the base uri
 375                          */
 376
 377                         separator = strchr (mutable_base_uri, ':');
 378
 379                         /* g_assert (separator), really */
 380                         if (separator) {
 381                                 /* If we start with //, skip past the authority section */
 382                                 if ('/' == separator[1] && '/' == separator[2]) {
 383                                         separator = strchr (separator + 3, '/');
 384                                         if (separator) {
 385                                                 separator[0] = '\0';
 386                                         }
 387                                 } else {
 388                                 /* If there's no //, just assume the scheme is the root */
 389                                         separator[1] = '\0';
 390                                 }
 391                         }
 392                 } else if ('#' != uri_current[0]) {
 393                         /* Handle the ".." convention for relative uri's */
 394
 395                         /* If there's a trailing '/' on base_url, treat base_url
 396                          * as a directory path.
 397                          * Otherwise, treat it as a file path, and chop off the filename
 398                          */
 399
 400                         base_uri_length = strlen (mutable_base_uri);
 401                         if ('/' == mutable_base_uri[base_uri_length-1]) {
 402                                 /* Trim off '/' for the operation below */
 403                                 mutable_base_uri[base_uri_length-1] = 0;
 404                         } else {
 405                                 separator = strrchr (mutable_base_uri, '/');
 406                                 if (separator) {
 407                                         *separator = '\0';
 408                                 }
 409                         }
 410
 411                         remove_internal_relative_components (uri_current);
 412
 413                         /* handle the "../"'s at the beginning of the relative URI */
 414                         while (0 == strncmp ("../", uri_current, 3)) {
 415                                 uri_current += 3;
 416                                 separator = strrchr (mutable_base_uri, '/');
 417                                 if (separator) {
 418                                         *separator = '\0';
 419                                 } else {
 420                                         /* <shrug> */
 421                                         break;
 422                                 }
 423                         }
 424
 425                         /* handle a ".." at the end */
 426                         if (uri_current[0] == '.' && uri_current[1] == '.'
 427                             && uri_current[2] == '\0') {
 428
 429                                 uri_current += 2;
 430                                 separator = strrchr (mutable_base_uri, '/');
 431                                 if (separator) {
 432                                         *separator = '\0';
 433                                 }
 434                         }
 435
 436                         /* Re-append the '/' */
 437                         mutable_base_uri [strlen(mutable_base_uri)+1] = '\0';
 438                         mutable_base_uri [strlen(mutable_base_uri)] = '/';
 439                 }
 440
 441                 result = g_strconcat (mutable_base_uri, uri_current, NULL);
 442                 g_free (mutable_base_uri);
 443                 g_free (mutable_uri);
 444         }
 445
 446         return result;
 447 }
 448
 449 /* Note that NULL's and full paths are also handled by this function.
 450  * A NULL location will return the current working directory
 451  */
 452 static char *
 453 file_uri_from_local_relative_path (const char *location)
 454 {
 455         char *current_dir;
 456         char *base_uri, *base_uri_slash;
 457         char *location_escaped;
 458         char *uri;
 459
 460         current_dir = g_get_current_dir ();
 461         base_uri = gnome_vfs_get_uri_from_local_path (current_dir);
 462         /* g_get_current_dir returns w/o trailing / */
 463         base_uri_slash = g_strconcat (base_uri, "/", NULL);
 464
 465         location_escaped = gnome_vfs_escape_path_string (location);
 466
 467         uri = eel_uri_make_full_from_relative (base_uri_slash, location_escaped);
 468
 469         g_free (location_escaped);
 470         g_free (base_uri_slash);
 471         g_free (base_uri);
 472         g_free (current_dir);
 473
 474         return uri;
 475 }
 476
 477 static gboolean
 478 has_valid_scheme (const char *uri)
 479 {
 480         const char *p;
 481
 482         p = uri;
 483
 484         if (!is_valid_scheme_character (*p)) {
 485                 return FALSE;
 486         }
 487
 488         do {
 489                 p++;
 490         } while (is_valid_scheme_character (*p));
 491
 492         return *p == ':';
 493 }
 494
 495 /**
 496  * eel_make_uri_from_shell_arg:
 497  *
 498  * Similar to eel_make_uri_from_input, except that:
 499  *
 500  * 1) guesses relative paths instead of http domains
 501  * 2) doesn't bother stripping leading/trailing white space
 502  * 3) doesn't bother with ~ expansion--that's done by the shell
 503  *
 504  * @location: a possibly mangled "uri"
 505  *
 506  * returns a newly allocated uri
 507  *
 508  **/
 509 char *
 510 rb_uri_resolve_relative (const char *location)
 511 {
 512         char *uri;
 513
 514         g_return_val_if_fail (location != NULL, g_strdup (""));
 515
 516         switch (location[0]) {
 517         case '\0':
 518                 uri = g_strdup ("");
 519                 break;
 520         case '/':
 521                 uri = gnome_vfs_get_uri_from_local_path (location);
 522                 break;
 523         default:
 524                 if (has_valid_scheme (location)) {
 525                         uri = g_strdup (location);
 526                 } else {
 527                         uri = file_uri_from_local_relative_path (location);
 528                 }
 529         }
 530
 531         return uri;
 532 }
 533
 534 static gboolean
 535 have_uid (guint uid)
 536 {
 537         return (uid == getuid ());
 538 }
 539
 540 static gboolean
 541 have_gid (guint gid)
 542 {
 543         gid_t gids[100];
 544         int n_groups, i;
 545
 546         n_groups = getgroups (100, gids);
 547
 548         for (i = 0; i < n_groups; i++)
 549         {
 550                 if (gids[i] == getegid ())
 551                         continue;
 552                 if (gids[i] == gid)
 553                         return TRUE;
 554         }
 555
 556         return FALSE;
 557 }
 558
 559 gboolean
 560 rb_uri_is_readable (const char *text_uri)
 561 {
 562         GnomeVFSFileInfo *info;
 563         gboolean ret = FALSE;
 564
 565         info = gnome_vfs_file_info_new ();
 566         if (info == NULL)
 567                 return FALSE;
 568         if (gnome_vfs_get_file_info (text_uri, info, GNOME_VFS_FILE_INFO_FOLLOW_LINKS) != GNOME_VFS_OK)
 569                 return FALSE;
 570
 571         if ((info->permissions & GNOME_VFS_PERM_OTHER_READ) ||
 572             ((info->permissions & GNOME_VFS_PERM_USER_READ) &&
 573              (have_uid (info->uid) == TRUE)) ||
 574             ((info->permissions & GNOME_VFS_PERM_GROUP_READ) &&
 575              (have_gid (info->gid) == TRUE)))
 576                 ret = TRUE;
 577
 578         gnome_vfs_file_info_unref (info);
 579
 580         return ret;
 581 }
 582
 583 gboolean
 584 rb_uri_is_writable (const char *text_uri)
 585 {
 586         GnomeVFSFileInfo *info;
 587         gboolean ret = FALSE;
 588
 589         info = gnome_vfs_file_info_new ();
 590         if (info == NULL)
 591                 return FALSE;
 592         if (gnome_vfs_get_file_info (text_uri, info, GNOME_VFS_FILE_INFO_FOLLOW_LINKS) != GNOME_VFS_OK)
 593                 return FALSE;
 594
 595         if ((info->permissions & GNOME_VFS_PERM_OTHER_WRITE) ||
 596             ((info->permissions & GNOME_VFS_PERM_USER_WRITE) &&
 597              (have_uid (info->uid) == TRUE)) ||
 598             ((info->permissions & GNOME_VFS_PERM_GROUP_WRITE) &&
 599              (have_gid (info->gid) == TRUE)))
 600                 ret = TRUE;
 601
 602         gnome_vfs_file_info_unref (info);
 603
 604         return ret;
 605 }
 606
 607 gboolean
 608 rb_uri_is_local (const char *text_uri)
 609 {
 610         return g_str_has_prefix (text_uri, "file://");
 611 }
 612
 613 /*
 614  * gnome_vfs_uri_new escapes a few extra characters that
 615  * gnome_vfs_escape_path doesn't ('&' and '=').  If we
 616  * don't adjust our URIs to match, we end up with duplicate
 617  * entries, one with the characters encoded and one without.
 618  */
 619 static char *
 620 escape_extra_gnome_vfs_chars (char *uri)
 621 {
 622         if (strspn (uri, "&=") != strlen (uri)) {
 623                 char *tmp = gnome_vfs_escape_set (uri, "&=");
 624                 g_free (uri);
 625                 return tmp;
 626         }
 627
 628         return uri;
 629 }
 630
 631 typedef struct {
 632         const char *uri;
 633         GFunc func;
 634         gpointer user_data;
 635         gboolean *cancel_flag;
 636 } RBUriHandleRecursivelyData;
 637
 638 static gboolean
 639 rb_uri_handle_recursively_cb (const gchar *rel_path,
 640                               GnomeVFSFileInfo *info,
 641                               gboolean recursing_will_loop,
 642                               RBUriHandleRecursivelyData *data,
 643                               gboolean *recurse)
 644 {
 645         if (data->cancel_flag && *data->cancel_flag)
 646                 return TRUE;
 647
 648         /* skip hidden and unreadable files and directories */
 649         if (g_str_has_prefix (rel_path, ".") ||
 650             ((info->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_ACCESS) &&
 651             !(info->permissions & GNOME_VFS_PERM_ACCESS_READABLE))) {
 652                 *recurse = FALSE;
 653                 return TRUE;
 654         }
 655
 656         if (info->type == GNOME_VFS_FILE_TYPE_REGULAR) {
 657                 char *path, *escaped_rel_path;
 658
 659                 escaped_rel_path = gnome_vfs_escape_path_string (rel_path);
 660                 escaped_rel_path = escape_extra_gnome_vfs_chars (escaped_rel_path);
 661                 path = g_build_filename (data->uri, escaped_rel_path, NULL);
 662                 (data->func) (path, data->user_data);
 663                 g_free (escaped_rel_path);
 664                 g_free (path);
 665         }
 666
 667         *recurse = !recursing_will_loop;
 668         return TRUE;
 669 }
 670
 671 void
 672 rb_uri_handle_recursively (const char *text_uri,
 673                            GFunc func,
 674                            gboolean *cancelflag,
 675                            gpointer user_data)
 676 {
 677         RBUriHandleRecursivelyData *data = g_new0 (RBUriHandleRecursivelyData, 1);
 678         GnomeVFSFileInfoOptions flags;
 679         GnomeVFSResult result;
 680
 681         data->uri = text_uri;
 682         data->func = func;
 683         data->user_data = user_data;
 684         data->cancel_flag = cancelflag;
 685
 686         flags = GNOME_VFS_FILE_INFO_GET_MIME_TYPE |
 687                 GNOME_VFS_FILE_INFO_FORCE_FAST_MIME_TYPE |
 688                 GNOME_VFS_FILE_INFO_FOLLOW_LINKS |
 689                 GNOME_VFS_FILE_INFO_GET_ACCESS_RIGHTS;
 690         result = gnome_vfs_directory_visit (text_uri,
 691                                             flags,
 692                                             GNOME_VFS_DIRECTORY_VISIT_LOOPCHECK,
 693                                             (GnomeVFSDirectoryVisitFunc)rb_uri_handle_recursively_cb,
 694                                             data);
 695         g_free (data);
 696 }
 697
 698 GnomeVFSResult
 699 rb_uri_mkstemp (const char *prefix, char **uri_ret, GnomeVFSHandle **ret)
 700 {
 701         GnomeVFSHandle *handle = NULL;
 702         char *uri = NULL;
 703         GnomeVFSResult result = GNOME_VFS_ERROR_FILE_EXISTS;
 704
 705
 706         do {
 707                 g_free (uri);
 708                 uri = g_strdup_printf ("%s%06X", prefix, g_random_int_range (0, 0xFFFFFF));
 709                 result = gnome_vfs_create (&handle, uri, GNOME_VFS_OPEN_WRITE | GNOME_VFS_OPEN_RANDOM, TRUE,  0644);
 710         } while (result == GNOME_VFS_ERROR_FILE_EXISTS);
 711
 712         if (result == GNOME_VFS_OK) {
 713                 *uri_ret = uri;
 714                 *ret = handle;
 715         } else {
 716                 g_free (uri);
 717         }
 718         return result;
 719 }
 720
 721
 722 char *
 723 rb_canonicalise_uri (const char *uri)
 724 {
 725         char *result = NULL;
 726
 727         if (uri[0] == '/') {
 728                 /* local path */
 729                 char *tmp;
 730                 result = gnome_vfs_make_path_name_canonical (uri);
 731                 tmp = gnome_vfs_escape_path_string (result);
 732                 g_free (result);
 733                 tmp = escape_extra_gnome_vfs_chars (tmp);
 734                 result = g_strconcat ("file://", tmp, NULL);
 735                 g_free (tmp);
 736         } else  if (g_str_has_prefix (uri, "file://")) {
 737                 /* local file, rhythmdb wants this path escaped */
 738                 char *tmp1, *tmp2;
 739                 tmp1  = gnome_vfs_unescape_string (uri + 7, NULL);  /* ignore "file://" */
 740                 tmp2 = gnome_vfs_escape_path_string (tmp1);
 741                 g_free (tmp1);
 742                 tmp2 = escape_extra_gnome_vfs_chars (tmp2);
 743                 result = g_strconcat ("file://", tmp2, NULL); /* re-add scheme */
 744                 g_free (tmp2);
 745         } else {
 746                 GnomeVFSURI *vfsuri = gnome_vfs_uri_new (uri);
 747
 748                 if (vfsuri != NULL) {
 749                         /* non-local uri, leave as-is */
 750                         gnome_vfs_uri_unref (vfsuri);
 751                         result = g_strdup (uri);
 752                 } else {
 753                         /* this may just mean that gnome-vfs doesn't recognise the
 754                          * uri scheme, so return it as is */
 755                         rb_debug ("Error processing probable URI %s", uri);
 756                         result = g_strdup (uri);
 757                 }
 758         }
 759
 760         return result;
 761 }
 762
 763 char*
 764 rb_uri_append_path (const char *uri, const char *path)
 765 {
 766         GnomeVFSURI *vfs_uri, *full_uri;
 767         char *result;
 768
 769         vfs_uri = gnome_vfs_uri_new (uri);
 770         full_uri = gnome_vfs_uri_append_path (vfs_uri, path);
 771         gnome_vfs_uri_unref (vfs_uri);
 772         result = gnome_vfs_uri_to_string (full_uri, GNOME_VFS_URI_HIDE_NONE);
 773         gnome_vfs_uri_unref (full_uri);
 774
 775         return result;
 776 }
 777
 778 char*
 779 rb_uri_append_uri (const char *uri, const char *fragment)
 780 {
 781         GnomeVFSURI *vfs_uri, *full_uri;
 782         char *result;
 783
 784         vfs_uri = gnome_vfs_uri_new (uri);
 785         full_uri = gnome_vfs_uri_append_string (vfs_uri, fragment);
 786         gnome_vfs_uri_unref (vfs_uri);
 787         result = gnome_vfs_uri_to_string (full_uri, GNOME_VFS_URI_HIDE_NONE);
 788         gnome_vfs_uri_unref (full_uri);
 789
 790         return result;
 791 }
 792
 793 char *
 794 rb_uri_get_dir_name (const char *uri)
 795 {
 796         GnomeVFSURI *vfs_uri;
 797         char *dirname;
 798
 799         vfs_uri = gnome_vfs_uri_new (uri);
 800         dirname = gnome_vfs_uri_extract_dirname (vfs_uri);
 801         gnome_vfs_uri_unref (vfs_uri);
 802
 803         return dirname;
 804 }
 805