gio/gvfs.c

   1 /* GIO - GLib Input, Output and Streaming Library
   2  *
   3  * Copyright (C) 2006-2007 Red Hat, Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General
  16  * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
  17  *
  18  * Author: Alexander Larsson <alexl@redhat.com>
  19  */
  20
  21 #include "config.h"
  22 #include <string.h>
  23 #include "gvfs.h"
  24 #include "glib-private.h"
  25 #include "glocalvfs.h"
  26 #include "gresourcefile.h"
  27 #include "giomodule-priv.h"
  28 #include "glibintl.h"
  29
  30
  31 /**
  32  * SECTION:gvfs
  33  * @short_description: Virtual File System
  34  * @include: gio/gio.h
  35  *
  36  * Entry point for using GIO functionality.
  37  *
  38  */
  39
  40 static GRWLock additional_schemes_lock;
  41
  42 typedef struct _GVfsPrivate {
  43   GHashTable *additional_schemes;
  44   char const **supported_schemes;
  45 } GVfsPrivate;
  46
  47 typedef struct {
  48   GVfsFileLookupFunc uri_func;
  49   gpointer uri_data;
  50   GDestroyNotify uri_destroy;
  51
  52   GVfsFileLookupFunc parse_name_func;
  53   gpointer parse_name_data;
  54   GDestroyNotify parse_name_destroy;
  55 } GVfsURISchemeData;
  56
  57 G_DEFINE_TYPE_WITH_PRIVATE (GVfs, g_vfs, G_TYPE_OBJECT)
  58
  59 static void
  60 g_vfs_dispose (GObject *object)
  61 {
  62   GVfs *vfs = G_VFS (object);
  63   GVfsPrivate *priv = g_vfs_get_instance_private (vfs);
  64
  65   g_clear_pointer (&priv->additional_schemes, g_hash_table_destroy);
  66   g_clear_pointer (&priv->supported_schemes, g_free);
  67
  68   G_OBJECT_CLASS (g_vfs_parent_class)->dispose (object);
  69 }
  70
  71 static void
  72 g_vfs_class_init (GVfsClass *klass)
  73 {
  74   GObjectClass *object_class = G_OBJECT_CLASS (klass);
  75   object_class->dispose = g_vfs_dispose;
  76 }
  77
  78 static GFile *
  79 resource_parse_name (GVfs       *vfs,
  80                      const char *parse_name,
  81                      gpointer    user_data)
  82 {
  83   if (g_str_has_prefix (parse_name, "resource:"))
  84     return _g_resource_file_new (parse_name);
  85
  86   return NULL;
  87 }
  88
  89 static GFile *
  90 resource_get_file_for_uri (GVfs       *vfs,
  91                            const char *uri,
  92                            gpointer    user_data)
  93 {
  94   return _g_resource_file_new (uri);
  95 }
  96
  97 static void
  98 g_vfs_uri_lookup_func_closure_free (gpointer data)
  99 {
 100   GVfsURISchemeData *closure = data;
 101
 102   if (closure->uri_destroy)
 103     closure->uri_destroy (closure->uri_data);
 104   if (closure->parse_name_destroy)
 105     closure->parse_name_destroy (closure->parse_name_data);
 106
 107   g_free (closure);
 108 }
 109
 110 static void
 111 g_vfs_init (GVfs *vfs)
 112 {
 113   GVfsPrivate *priv = g_vfs_get_instance_private (vfs);
 114   priv->additional_schemes =
 115     g_hash_table_new_full (g_str_hash, g_str_equal,
 116                            g_free, g_vfs_uri_lookup_func_closure_free);
 117
 118   g_vfs_register_uri_scheme (vfs, "resource",
 119                              resource_get_file_for_uri, NULL, NULL,
 120                              resource_parse_name, NULL, NULL);
 121 }
 122
 123 /**
 124  * g_vfs_is_active:
 125  * @vfs: a #GVfs.
 126  *
 127  * Checks if the VFS is active.
 128  *
 129  * Returns: %TRUE if construction of the @vfs was successful
 130  *     and it is now active.
 131  */
 132 gboolean
 133 g_vfs_is_active (GVfs *vfs)
 134 {
 135   GVfsClass *class;
 136
 137   g_return_val_if_fail (G_IS_VFS (vfs), FALSE);
 138
 139   class = G_VFS_GET_CLASS (vfs);
 140
 141   return (* class->is_active) (vfs);
 142 }
 143
 144
 145 /**
 146  * g_vfs_get_file_for_path:
 147  * @vfs: a #GVfs.
 148  * @path: a string containing a VFS path.
 149  *
 150  * Gets a #GFile for @path.
 151  *
 152  * Returns: (transfer full): a #GFile.
 153  *     Free the returned object with g_object_unref().
 154  */
 155 GFile *
 156 g_vfs_get_file_for_path (GVfs       *vfs,
 157                          const char *path)
 158 {
 159   GVfsClass *class;
 160
 161   g_return_val_if_fail (G_IS_VFS (vfs), NULL);
 162   g_return_val_if_fail (path != NULL, NULL);
 163
 164   class = G_VFS_GET_CLASS (vfs);
 165
 166   return (* class->get_file_for_path) (vfs, path);
 167 }
 168
 169 static GFile *
 170 parse_name_internal (GVfs       *vfs,
 171                      const char *parse_name)
 172 {
 173   GVfsPrivate *priv = g_vfs_get_instance_private (vfs);
 174   GHashTableIter iter;
 175   GVfsURISchemeData *closure;
 176   GFile *ret = NULL;
 177
 178   g_rw_lock_reader_lock (&additional_schemes_lock);
 179   g_hash_table_iter_init (&iter, priv->additional_schemes);
 180
 181   while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &closure))
 182     {
 183       ret = closure->parse_name_func (vfs, parse_name,
 184                                       closure->parse_name_data);
 185
 186       if (ret)
 187         break;
 188     }
 189
 190   g_rw_lock_reader_unlock (&additional_schemes_lock);
 191
 192   return ret;
 193 }
 194
 195 static GFile *
 196 get_file_for_uri_internal (GVfs       *vfs,
 197                            const char *uri)
 198 {
 199   GVfsPrivate *priv = g_vfs_get_instance_private (vfs);
 200   GFile *ret = NULL;
 201   char *scheme;
 202   GVfsURISchemeData *closure;
 203
 204   scheme = g_uri_parse_scheme (uri);
 205   if (scheme == NULL)
 206     return NULL;
 207
 208   g_rw_lock_reader_lock (&additional_schemes_lock);
 209   closure = g_hash_table_lookup (priv->additional_schemes, scheme);
 210
 211   if (closure)
 212     ret = closure->uri_func (vfs, uri, closure->uri_data);
 213
 214   g_rw_lock_reader_unlock (&additional_schemes_lock);
 215
 216   g_free (scheme);
 217   return ret;
 218 }
 219
 220 /**
 221  * g_vfs_get_file_for_uri:
 222  * @vfs: a#GVfs.
 223  * @uri: a string containing a URI
 224  *
 225  * Gets a #GFile for @uri.
 226  *
 227  * This operation never fails, but the returned object
 228  * might not support any I/O operation if the URI
 229  * is malformed or if the URI scheme is not supported.
 230  *
 231  * Returns: (transfer full): a #GFile.
 232  *     Free the returned object with g_object_unref().
 233  */
 234 GFile *
 235 g_vfs_get_file_for_uri (GVfs       *vfs,
 236                         const char *uri)
 237 {
 238   GVfsClass *class;
 239   GFile *ret = NULL;
 240
 241   g_return_val_if_fail (G_IS_VFS (vfs), NULL);
 242   g_return_val_if_fail (uri != NULL, NULL);
 243
 244   class = G_VFS_GET_CLASS (vfs);
 245
 246   ret = get_file_for_uri_internal (vfs, uri);
 247   if (!ret)
 248     ret = (* class->get_file_for_uri) (vfs, uri);
 249
 250   g_assert (ret != NULL);
 251
 252   return g_steal_pointer (&ret);
 253 }
 254
 255 /**
 256  * g_vfs_get_supported_uri_schemes:
 257  * @vfs: a #GVfs.
 258  *
 259  * Gets a list of URI schemes supported by @vfs.
 260  *
 261  * Returns: (transfer none): a %NULL-terminated array of strings.
 262  *     The returned array belongs to GIO and must
 263  *     not be freed or modified.
 264  */
 265 const gchar * const *
 266 g_vfs_get_supported_uri_schemes (GVfs *vfs)
 267 {
 268   GVfsPrivate *priv;
 269
 270   g_return_val_if_fail (G_IS_VFS (vfs), NULL);
 271
 272   priv = g_vfs_get_instance_private (vfs);
 273
 274   if (!priv->supported_schemes)
 275     {
 276       GVfsClass *class;
 277       const char * const *default_schemes;
 278       const char *additional_scheme;
 279       GPtrArray *supported_schemes;
 280       GHashTableIter iter;
 281
 282       class = G_VFS_GET_CLASS (vfs);
 283
 284       default_schemes = (* class->get_supported_uri_schemes) (vfs);
 285       supported_schemes = g_ptr_array_new ();
 286
 287       for (; default_schemes && *default_schemes; default_schemes++)
 288         g_ptr_array_add (supported_schemes, (gpointer) *default_schemes);
 289
 290       g_rw_lock_reader_lock (&additional_schemes_lock);
 291       g_hash_table_iter_init (&iter, priv->additional_schemes);
 292
 293       while (g_hash_table_iter_next
 294              (&iter, (gpointer *) &additional_scheme, NULL))
 295         g_ptr_array_add (supported_schemes, (gpointer) additional_scheme);
 296
 297       g_rw_lock_reader_unlock (&additional_schemes_lock);
 298
 299       g_ptr_array_add (supported_schemes, NULL);
 300
 301       g_free (priv->supported_schemes);
 302       priv->supported_schemes =
 303         (char const **) g_ptr_array_free (supported_schemes, FALSE);
 304     }
 305
 306   return priv->supported_schemes;
 307 }
 308
 309 /**
 310  * g_vfs_parse_name:
 311  * @vfs: a #GVfs.
 312  * @parse_name: a string to be parsed by the VFS module.
 313  *
 314  * This operation never fails, but the returned object might
 315  * not support any I/O operations if the @parse_name cannot
 316  * be parsed by the #GVfs module.
 317  *
 318  * Returns: (transfer full): a #GFile for the given @parse_name.
 319  *     Free the returned object with g_object_unref().
 320  */
 321 GFile *
 322 g_vfs_parse_name (GVfs       *vfs,
 323                   const char *parse_name)
 324 {
 325   GVfsClass *class;
 326   GFile *ret;
 327
 328   g_return_val_if_fail (G_IS_VFS (vfs), NULL);
 329   g_return_val_if_fail (parse_name != NULL, NULL);
 330
 331   class = G_VFS_GET_CLASS (vfs);
 332
 333   ret = parse_name_internal (vfs, parse_name);
 334   if (ret)
 335     return ret;
 336
 337   return (* class->parse_name) (vfs, parse_name);
 338 }
 339
 340 /**
 341  * g_vfs_get_default:
 342  *
 343  * Gets the default #GVfs for the system.
 344  *
 345  * Returns: (transfer none): a #GVfs.
 346  */
 347 GVfs *
 348 g_vfs_get_default (void)
 349 {
 350   if (GLIB_PRIVATE_CALL (g_check_setuid) ())
 351     return g_vfs_get_local ();
 352   return _g_io_module_get_default (G_VFS_EXTENSION_POINT_NAME,
 353                                    "GIO_USE_VFS",
 354                                    (GIOModuleVerifyFunc)g_vfs_is_active);
 355 }
 356
 357 /**
 358  * g_vfs_get_local:
 359  *
 360  * Gets the local #GVfs for the system.
 361  *
 362  * Returns: (transfer none): a #GVfs.
 363  */
 364 GVfs *
 365 g_vfs_get_local (void)
 366 {
 367   static gsize vfs = 0;
 368
 369   if (g_once_init_enter (&vfs))
 370     g_once_init_leave (&vfs, (gsize)_g_local_vfs_new ());
 371
 372   return G_VFS (vfs);
 373 }
 374
 375 /**
 376  * g_vfs_register_uri_scheme:
 377  * @vfs: a #GVfs
 378  * @scheme: an URI scheme, e.g. "http"
 379  * @uri_func: (scope notified) (nullable): a #GVfsFileLookupFunc
 380  * @uri_data: (nullable): custom data passed to be passed to @uri_func, or %NULL
 381  * @uri_destroy: (nullable): function to be called when unregistering the
 382  *     URI scheme, or when @vfs is disposed, to free the resources used
 383  *     by the URI lookup function
 384  * @parse_name_func: (scope notified) (nullable): a #GVfsFileLookupFunc
 385  * @parse_name_data: (nullable): custom data passed to be passed to
 386  *     @parse_name_func, or %NULL
 387  * @parse_name_destroy: (nullable): function to be called when unregistering the
 388  *     URI scheme, or when @vfs is disposed, to free the resources used
 389  *     by the parse name lookup function
 390  *
 391  * Registers @uri_func and @parse_name_func as the #GFile URI and parse name
 392  * lookup functions for URIs with a scheme matching @scheme.
 393  * Note that @scheme is registered only within the running application, as
 394  * opposed to desktop-wide as it happens with GVfs backends.
 395  *
 396  * When a #GFile is requested with an URI containing @scheme (e.g. through
 397  * g_file_new_for_uri()), @uri_func will be called to allow a custom
 398  * constructor. The implementation of @uri_func should not be blocking, and
 399  * must not call g_vfs_register_uri_scheme() or g_vfs_unregister_uri_scheme().
 400  *
 401  * When g_file_parse_name() is called with a parse name obtained from such file,
 402  * @parse_name_func will be called to allow the #GFile to be created again. In
 403  * that case, it's responsibility of @parse_name_func to make sure the parse
 404  * name matches what the custom #GFile implementation returned when
 405  * g_file_get_parse_name() was previously called. The implementation of
 406  * @parse_name_func should not be blocking, and must not call
 407  * g_vfs_register_uri_scheme() or g_vfs_unregister_uri_scheme().
 408  *
 409  * It's an error to call this function twice with the same scheme. To unregister
 410  * a custom URI scheme, use g_vfs_unregister_uri_scheme().
 411  *
 412  * Returns: %TRUE if @scheme was successfully registered, or %FALSE if a handler
 413  *     for @scheme already exists.
 414  *
 415  * Since: 2.50
 416  */
 417 gboolean
 418 g_vfs_register_uri_scheme (GVfs              *vfs,
 419                            const char        *scheme,
 420                            GVfsFileLookupFunc uri_func,
 421                            gpointer           uri_data,
 422                            GDestroyNotify     uri_destroy,
 423                            GVfsFileLookupFunc parse_name_func,
 424                            gpointer           parse_name_data,
 425                            GDestroyNotify     parse_name_destroy)
 426 {
 427   GVfsPrivate *priv;
 428   GVfsURISchemeData *closure;
 429
 430   g_return_val_if_fail (G_IS_VFS (vfs), FALSE);
 431   g_return_val_if_fail (scheme != NULL, FALSE);
 432
 433   priv = g_vfs_get_instance_private (vfs);
 434
 435   g_rw_lock_reader_lock (&additional_schemes_lock);
 436   closure = g_hash_table_lookup (priv->additional_schemes, scheme);
 437   g_rw_lock_reader_unlock (&additional_schemes_lock);
 438
 439   if (closure != NULL)
 440     return FALSE;
 441
 442   closure = g_new0 (GVfsURISchemeData, 1);
 443   closure->uri_func = uri_func;
 444   closure->uri_data = uri_data;
 445   closure->uri_destroy = uri_destroy;
 446   closure->parse_name_func = parse_name_func;
 447   closure->parse_name_data = parse_name_data;
 448   closure->parse_name_destroy = parse_name_destroy;
 449
 450   g_rw_lock_writer_lock (&additional_schemes_lock);
 451   g_hash_table_insert (priv->additional_schemes, g_strdup (scheme), closure);
 452   g_rw_lock_writer_unlock (&additional_schemes_lock);
 453
 454   /* Invalidate supported schemes */
 455   g_clear_pointer (&priv->supported_schemes, g_free);
 456
 457   return TRUE;
 458 }
 459
 460 /**
 461  * g_vfs_unregister_uri_scheme:
 462  * @vfs: a #GVfs
 463  * @scheme: an URI scheme, e.g. "http"
 464  *
 465  * Unregisters the URI handler for @scheme previously registered with
 466  * g_vfs_register_uri_scheme().
 467  *
 468  * Returns: %TRUE if @scheme was successfully unregistered, or %FALSE if a
 469  *     handler for @scheme does not exist.
 470  *
 471  * Since: 2.50
 472  */
 473 gboolean
 474 g_vfs_unregister_uri_scheme (GVfs       *vfs,
 475                              const char *scheme)
 476 {
 477   GVfsPrivate *priv;
 478   gboolean res;
 479
 480   g_return_val_if_fail (G_IS_VFS (vfs), FALSE);
 481   g_return_val_if_fail (scheme != NULL, FALSE);
 482
 483   priv = g_vfs_get_instance_private (vfs);
 484
 485   g_rw_lock_writer_lock (&additional_schemes_lock);
 486   res = g_hash_table_remove (priv->additional_schemes, scheme);
 487   g_rw_lock_writer_unlock (&additional_schemes_lock);
 488
 489   if (res)
 490     {
 491       /* Invalidate supported schemes */
 492       g_clear_pointer (&priv->supported_schemes, g_free);
 493
 494       return TRUE;
 495     }
 496
 497   return FALSE;
 498 }