gio/giomodule.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 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, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  *
  20  * Author: Alexander Larsson <alexl@redhat.com>
  21  */
  22
  23 #include "config.h"
  24
  25 #include <string.h>
  26
  27 #include "giomodule.h"
  28 #include "giomodule-priv.h"
  29 #include "glocalfilemonitor.h"
  30 #include "glocaldirectorymonitor.h"
  31 #include "gnativevolumemonitor.h"
  32 #include "gvfs.h"
  33 #ifdef G_OS_UNIX
  34 #include "gdesktopappinfo.h"
  35 #endif
  36 #include "gioalias.h"
  37
  38 /**
  39  * SECTION:giomodule
  40  * @short_description: Loadable GIO Modules
  41  * @include: gio/gio.h
  42  *
  43  * Provides an interface and default functions for loading and unloading
  44  * modules. This is used internally to make GIO extensible, but can also
  45  * be used by others to implement module loading.
  46  *
  47  **/
  48
  49 /**
  50  * SECTION:extensionpoints
  51  * @short_description: Extension Points
  52  * @include: gio.h
  53  * @see_also: <link linkend="extending-gio">Extending GIO</link>
  54  *
  55  * #GIOExtensionPoint provides a mechanism for modules to extend the
  56  * functionality of the library or application that loaded it in an
  57  * organized fashion.
  58  *
  59  * An extension point is identified by a name, and it may optionally
  60  * require that any implementation must by of a certain type (or derived
  61  * thereof). Use g_io_extension_point_register() to register an
  62  * extension point, and g_io_extension_point_set_required_type() to
  63  * set a required type.
  64  *
  65  * A module can implement an extension point by specifying the #GType
  66  * that implements the functionality. Additionally, each implementation
  67  * of an extension point has a name, and a priority. Use
  68  * g_io_extension_point_implement() to implement an extension point.
  69  *
  70  *  |[
  71  *  GIOExtensionPoint *ep;
  72  *
  73  *  /&ast; Register an extension point &ast;/
  74  *  ep = g_io_extension_point_register ("my-extension-point");
  75  *  g_io_extension_point_set_required_type (ep, MY_TYPE_EXAMPLE);
  76  *  ]|
  77  *
  78  *  |[
  79  *  /&ast; Implement an extension point &ast;/
  80  *  G_DEFINE_TYPE (MyExampleImpl, my_example_impl, MY_TYPE_EXAMPLE);
  81  *  g_io_extension_point_implement ("my-extension-point",
  82  *                                  my_example_impl_get_type (),
  83  *                                  "my-example",
  84  *                                  10);
  85  *  ]|
  86  *
  87  *  It is up to the code that registered the extension point how
  88  *  it uses the implementations that have been associated with it.
  89  *  Depending on the use case, it may use all implementations, or
  90  *  only the one with the highest priority, or pick a specific
  91  *  one by name.
  92  */
  93 struct _GIOModule {
  94   GTypeModule parent_instance;
  95
  96   gchar       *filename;
  97   GModule     *library;
  98
  99   void (* load)   (GIOModule *module);
 100   void (* unload) (GIOModule *module);
 101 };
 102
 103 struct _GIOModuleClass
 104 {
 105   GTypeModuleClass parent_class;
 106
 107 };
 108
 109 static void      g_io_module_finalize      (GObject      *object);
 110 static gboolean  g_io_module_load_module   (GTypeModule  *gmodule);
 111 static void      g_io_module_unload_module (GTypeModule  *gmodule);
 112
 113 G_DEFINE_TYPE (GIOModule, g_io_module, G_TYPE_TYPE_MODULE);
 114
 115 static void
 116 g_io_module_class_init (GIOModuleClass *class)
 117 {
 118   GObjectClass     *object_class      = G_OBJECT_CLASS (class);
 119   GTypeModuleClass *type_module_class = G_TYPE_MODULE_CLASS (class);
 120
 121   object_class->finalize     = g_io_module_finalize;
 122
 123   type_module_class->load    = g_io_module_load_module;
 124   type_module_class->unload  = g_io_module_unload_module;
 125 }
 126
 127 static void
 128 g_io_module_init (GIOModule *module)
 129 {
 130 }
 131
 132 static void
 133 g_io_module_finalize (GObject *object)
 134 {
 135   GIOModule *module = G_IO_MODULE (object);
 136
 137   g_free (module->filename);
 138
 139   G_OBJECT_CLASS (g_io_module_parent_class)->finalize (object);
 140 }
 141
 142 static gboolean
 143 g_io_module_load_module (GTypeModule *gmodule)
 144 {
 145   GIOModule *module = G_IO_MODULE (gmodule);
 146
 147   if (!module->filename)
 148     {
 149       g_warning ("GIOModule path not set");
 150       return FALSE;
 151     }
 152
 153   module->library = g_module_open (module->filename, G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL);
 154
 155   if (!module->library)
 156     {
 157       g_printerr ("%s\n", g_module_error ());
 158       return FALSE;
 159     }
 160
 161   /* Make sure that the loaded library contains the required methods */
 162   if (! g_module_symbol (module->library,
 163                          "g_io_module_load",
 164                          (gpointer) &module->load) ||
 165       ! g_module_symbol (module->library,
 166                          "g_io_module_unload",
 167                          (gpointer) &module->unload))
 168     {
 169       g_printerr ("%s\n", g_module_error ());
 170       g_module_close (module->library);
 171
 172       return FALSE;
 173     }
 174
 175   /* Initialize the loaded module */
 176   module->load (module);
 177
 178   return TRUE;
 179 }
 180
 181 static void
 182 g_io_module_unload_module (GTypeModule *gmodule)
 183 {
 184   GIOModule *module = G_IO_MODULE (gmodule);
 185
 186   module->unload (module);
 187
 188   g_module_close (module->library);
 189   module->library = NULL;
 190
 191   module->load   = NULL;
 192   module->unload = NULL;
 193 }
 194
 195 /**
 196  * g_io_module_new:
 197  * @filename: filename of the shared library module.
 198  *
 199  * Creates a new GIOModule that will load the specific
 200  * shared library when in use.
 201  *
 202  * Returns: a #GIOModule from given @filename,
 203  * or %NULL on error.
 204  **/
 205 GIOModule *
 206 g_io_module_new (const gchar *filename)
 207 {
 208   GIOModule *module;
 209
 210   g_return_val_if_fail (filename != NULL, NULL);
 211
 212   module = g_object_new (G_IO_TYPE_MODULE, NULL);
 213   module->filename = g_strdup (filename);
 214
 215   return module;
 216 }
 217
 218 static gboolean
 219 is_valid_module_name (const gchar *basename)
 220 {
 221 #if !defined(G_OS_WIN32) && !defined(G_WITH_CYGWIN)
 222   return
 223     g_str_has_prefix (basename, "lib") &&
 224     g_str_has_suffix (basename, ".so");
 225 #else
 226   return g_str_has_suffix (basename, ".dll");
 227 #endif
 228 }
 229
 230 /**
 231  * g_io_modules_load_all_in_directory:
 232  * @dirname: pathname for a directory containing modules to load.
 233  *
 234  * Loads all the modules in the specified directory.
 235  *
 236  * Returns: a list of #GIOModules loaded from the directory,
 237  *      All the modules are loaded into memory, if you want to
 238  *      unload them (enabling on-demand loading) you must call
 239  *      g_type_module_unuse() on all the modules. Free the list
 240  *      with g_list_free().
 241  **/
 242 GList *
 243 g_io_modules_load_all_in_directory (const char *dirname)
 244 {
 245   const gchar *name;
 246   GDir        *dir;
 247   GList *modules;
 248
 249   if (!g_module_supported ())
 250     return NULL;
 251
 252   dir = g_dir_open (dirname, 0, NULL);
 253   if (!dir)
 254     return NULL;
 255
 256   modules = NULL;
 257   while ((name = g_dir_read_name (dir)))
 258     {
 259       if (is_valid_module_name (name))
 260         {
 261           GIOModule *module;
 262           gchar     *path;
 263
 264           path = g_build_filename (dirname, name, NULL);
 265           module = g_io_module_new (path);
 266
 267           if (!g_type_module_use (G_TYPE_MODULE (module)))
 268             {
 269               g_printerr ("Failed to load module: %s\n", path);
 270               g_object_unref (module);
 271               g_free (path);
 272               continue;
 273             }
 274
 275           g_free (path);
 276
 277           modules = g_list_prepend (modules, module);
 278         }
 279     }
 280
 281   g_dir_close (dir);
 282
 283   return modules;
 284 }
 285
 286 G_LOCK_DEFINE_STATIC (registered_extensions);
 287 G_LOCK_DEFINE_STATIC (loaded_dirs);
 288
 289 extern GType _g_fen_directory_monitor_get_type (void);
 290 extern GType _g_fen_file_monitor_get_type (void);
 291 extern GType _g_inotify_directory_monitor_get_type (void);
 292 extern GType _g_inotify_file_monitor_get_type (void);
 293 extern GType _g_unix_volume_monitor_get_type (void);
 294 extern GType _g_local_vfs_get_type (void);
 295
 296 extern GType _g_win32_volume_monitor_get_type (void);
 297 extern GType g_win32_directory_monitor_get_type (void);
 298 extern GType _g_winhttp_vfs_get_type (void);
 299
 300 void
 301 _g_io_modules_ensure_extension_points_registered (void)
 302 {
 303   static gboolean registered_extensions = FALSE;
 304   GIOExtensionPoint *ep;
 305
 306   G_LOCK (registered_extensions);
 307
 308   if (!registered_extensions)
 309     {
 310       registered_extensions = TRUE;
 311
 312 #ifdef G_OS_UNIX
 313       ep = g_io_extension_point_register (G_DESKTOP_APP_INFO_LOOKUP_EXTENSION_POINT_NAME);
 314       g_io_extension_point_set_required_type (ep, G_TYPE_DESKTOP_APP_INFO_LOOKUP);
 315 #endif
 316
 317       ep = g_io_extension_point_register (G_LOCAL_DIRECTORY_MONITOR_EXTENSION_POINT_NAME);
 318       g_io_extension_point_set_required_type (ep, G_TYPE_LOCAL_DIRECTORY_MONITOR);
 319
 320       ep = g_io_extension_point_register (G_LOCAL_FILE_MONITOR_EXTENSION_POINT_NAME);
 321       g_io_extension_point_set_required_type (ep, G_TYPE_LOCAL_FILE_MONITOR);
 322
 323       ep = g_io_extension_point_register (G_VOLUME_MONITOR_EXTENSION_POINT_NAME);
 324       g_io_extension_point_set_required_type (ep, G_TYPE_VOLUME_MONITOR);
 325
 326       ep = g_io_extension_point_register (G_NATIVE_VOLUME_MONITOR_EXTENSION_POINT_NAME);
 327       g_io_extension_point_set_required_type (ep, G_TYPE_NATIVE_VOLUME_MONITOR);
 328
 329       ep = g_io_extension_point_register (G_VFS_EXTENSION_POINT_NAME);
 330       g_io_extension_point_set_required_type (ep, G_TYPE_VFS);
 331
 332       ep = g_io_extension_point_register ("gsettings-backend");
 333       g_io_extension_point_set_required_type (ep, G_TYPE_OBJECT);
 334     }
 335
 336   G_UNLOCK (registered_extensions);
 337  }
 338
 339 void
 340 _g_io_modules_ensure_loaded (void)
 341 {
 342   GList *modules, *l;
 343   static gboolean loaded_dirs = FALSE;
 344   const char *module_path;
 345
 346   _g_io_modules_ensure_extension_points_registered ();
 347
 348   G_LOCK (loaded_dirs);
 349
 350   if (!loaded_dirs)
 351     {
 352       loaded_dirs = TRUE;
 353
 354       modules = g_io_modules_load_all_in_directory (GIO_MODULE_DIR);
 355
 356       module_path = g_getenv ("GIO_EXTRA_MODULES");
 357
 358       if (module_path)
 359         {
 360           int i = 0;
 361           gchar **paths;
 362           paths = g_strsplit (module_path, ":", 0);
 363
 364           while (paths[i] != NULL)
 365             {
 366               modules = g_list_concat (modules, g_io_modules_load_all_in_directory (paths[i]));
 367               i++;
 368             }
 369
 370           g_strfreev (paths);
 371         }
 372
 373       /* Initialize types from built-in "modules" */
 374 #if defined(HAVE_SYS_INOTIFY_H) || defined(HAVE_LINUX_INOTIFY_H)
 375       _g_inotify_directory_monitor_get_type ();
 376       _g_inotify_file_monitor_get_type ();
 377 #endif
 378 #if defined(HAVE_FEN)
 379       _g_fen_directory_monitor_get_type ();
 380       _g_fen_file_monitor_get_type ();
 381 #endif
 382 #ifdef G_OS_WIN32
 383       _g_win32_volume_monitor_get_type ();
 384       g_win32_directory_monitor_get_type ();
 385 #endif
 386 #ifdef G_OS_UNIX
 387       _g_unix_volume_monitor_get_type ();
 388 #endif
 389 #ifdef G_OS_WIN32
 390       _g_winhttp_vfs_get_type ();
 391 #endif
 392       _g_local_vfs_get_type ();
 393
 394       for (l = modules; l != NULL; l = l->next)
 395         g_type_module_unuse (G_TYPE_MODULE (l->data));
 396
 397       g_list_free (modules);
 398     }
 399
 400   G_UNLOCK (loaded_dirs);
 401 }
 402
 403 struct _GIOExtension {
 404   char *name;
 405   GType type;
 406   gint priority;
 407 };
 408
 409 struct _GIOExtensionPoint {
 410   GType required_type;
 411   char *name;
 412   GList *extensions;
 413 };
 414
 415 static GHashTable *extension_points = NULL;
 416 G_LOCK_DEFINE_STATIC(extension_points);
 417
 418
 419 static void
 420 g_io_extension_point_free (GIOExtensionPoint *ep)
 421 {
 422   g_free (ep->name);
 423   g_free (ep);
 424 }
 425
 426 /**
 427  * g_io_extension_point_register:
 428  * @name: The name of the extension point
 429  *
 430  * Registers an extension point.
 431  *
 432  * Returns: the new #GIOExtensionPoint. This object is owned by GIO
 433  *    and should not be freed
 434  */
 435 GIOExtensionPoint *
 436 g_io_extension_point_register (const char *name)
 437 {
 438   GIOExtensionPoint *ep;
 439
 440   G_LOCK (extension_points);
 441   if (extension_points == NULL)
 442     extension_points = g_hash_table_new_full (g_str_hash,
 443                                               g_str_equal,
 444                                               NULL,
 445                                               (GDestroyNotify)g_io_extension_point_free);
 446
 447   if (g_hash_table_lookup (extension_points, name) != NULL)
 448     {
 449       g_warning ("Extension point %s registered multiple times", name);
 450       G_UNLOCK (extension_points);
 451       return NULL;
 452     }
 453
 454   ep = g_new0 (GIOExtensionPoint, 1);
 455   ep->name = g_strdup (name);
 456
 457   g_hash_table_insert (extension_points, ep->name, ep);
 458
 459   G_UNLOCK (extension_points);
 460
 461   return ep;
 462 }
 463
 464 /**
 465  * g_io_extension_point_lookup:
 466  * @name: the name of the extension point
 467  *
 468  * Looks up an existing extension point.
 469  *
 470  * Returns: the #GIOExtensionPoint, or %NULL if there is no
 471  *    registered extension point with the given name
 472  */
 473 GIOExtensionPoint *
 474 g_io_extension_point_lookup (const char *name)
 475 {
 476   GIOExtensionPoint *ep;
 477
 478   G_LOCK (extension_points);
 479   ep = NULL;
 480   if (extension_points != NULL)
 481     ep = g_hash_table_lookup (extension_points, name);
 482
 483   G_UNLOCK (extension_points);
 484
 485   return ep;
 486
 487 }
 488
 489 /**
 490  * g_io_extension_point_set_required_type:
 491  * @extension_point: a #GIOExtensionPoint
 492  * @type: the #GType to require
 493  *
 494  * Sets the required type for @extension_point to @type.
 495  * All implementations must henceforth have this type.
 496  */
 497 void
 498 g_io_extension_point_set_required_type (GIOExtensionPoint *extension_point,
 499                                         GType              type)
 500 {
 501   extension_point->required_type = type;
 502 }
 503
 504 /**
 505  * g_io_extension_point_get_required_type:
 506  * @extension_point: a #GIOExtensionPoint
 507  *
 508  * Gets the required type for @extension_point.
 509  *
 510  * Returns: the #GType that all implementations must have,
 511  *     or #G_TYPE_INVALID if the extension point has no required type
 512  */
 513 GType
 514 g_io_extension_point_get_required_type (GIOExtensionPoint *extension_point)
 515 {
 516   return extension_point->required_type;
 517 }
 518
 519 /**
 520  * g_io_extension_point_get_extensions:
 521  * @extension_point: a #GIOExtensionPoint
 522  *
 523  * Gets a list of all extensions that implement this extension point.
 524  * The list is sorted by priority, beginning with the highest priority.
 525  *
 526  * Returns: a #GList of #GIOExtension<!-- -->s. The list is owned by
 527  *   GIO and should not be modified
 528  */
 529 GList *
 530 g_io_extension_point_get_extensions (GIOExtensionPoint *extension_point)
 531 {
 532   return extension_point->extensions;
 533 }
 534
 535 /**
 536  * g_io_extension_point_get_extension_by_name:
 537  * @extension_point: a #GIOExtensionPoint
 538  * @name: the name of the extension to get
 539  *
 540  * Finds a #GIOExtension for an extension point by name.
 541  *
 542  * Returns: the #GIOExtension for @extension_point that has the
 543  *    given name, or %NULL if there is no extension with that name
 544  */
 545 GIOExtension *
 546 g_io_extension_point_get_extension_by_name (GIOExtensionPoint *extension_point,
 547                                             const char        *name)
 548 {
 549   GList *l;
 550
 551   for (l = extension_point->extensions; l != NULL; l = l->next)
 552     {
 553       GIOExtension *e = l->data;
 554
 555       if (e->name != NULL &&
 556           strcmp (e->name, name) == 0)
 557         return e;
 558     }
 559
 560   return NULL;
 561 }
 562
 563 static gint
 564 extension_prio_compare (gconstpointer  a,
 565                         gconstpointer  b)
 566 {
 567   const GIOExtension *extension_a = a, *extension_b = b;
 568
 569   return extension_b->priority - extension_a->priority;
 570 }
 571
 572 /**
 573  * g_io_extension_point_implement:
 574  * @extension_point_name: the name of the extension point
 575  * @type: the #GType to register as extension
 576  * @extension_name: the name for the extension
 577  * @priority: the priority for the extension
 578  *
 579  * Registers @type as extension for the extension point with name
 580  * @extension_point_name.
 581  *
 582  * If @type has already been registered as an extension for this
 583  * extension point, the existing #GIOExtension object is returned.
 584  *
 585  * Returns: a #GIOExtension object for #GType
 586  */
 587 GIOExtension *
 588 g_io_extension_point_implement (const char *extension_point_name,
 589                                 GType       type,
 590                                 const char *extension_name,
 591                                 gint        priority)
 592 {
 593   GIOExtensionPoint *extension_point;
 594   GIOExtension *extension;
 595   GList *l;
 596
 597   g_return_val_if_fail (extension_point_name != NULL, NULL);
 598
 599   extension_point = g_io_extension_point_lookup (extension_point_name);
 600   if (extension_point == NULL)
 601     {
 602       g_warning ("Tried to implement non-registered extension point %s", extension_point_name);
 603       return NULL;
 604     }
 605
 606   if (extension_point->required_type != 0 &&
 607       !g_type_is_a (type, extension_point->required_type))
 608     {
 609       g_warning ("Tried to register an extension of the type %s to extension point %s. "
 610                  "Expected type is %s.",
 611                  g_type_name (type),
 612                  extension_point_name,
 613                  g_type_name (extension_point->required_type));
 614       return NULL;
 615     }
 616
 617   /* It's safe to register the same type multiple times */
 618   for (l = extension_point->extensions; l != NULL; l = l->next)
 619     {
 620       extension = l->data;
 621       if (extension->type == type)
 622         return extension;
 623     }
 624
 625   extension = g_slice_new0 (GIOExtension);
 626   extension->type = type;
 627   extension->name = g_strdup (extension_name);
 628   extension->priority = priority;
 629
 630   extension_point->extensions = g_list_insert_sorted (extension_point->extensions,
 631                                                       extension, extension_prio_compare);
 632
 633   return extension;
 634 }
 635
 636 /**
 637  * g_io_extension_ref_class:
 638  * @extension: a #GIOExtension
 639  *
 640  * Gets a reference to the class for the type that is
 641  * associated with @extension.
 642  *
 643  * Returns: the #GTypeClass for the type of @extension
 644  */
 645 GTypeClass *
 646 g_io_extension_ref_class (GIOExtension *extension)
 647 {
 648   return g_type_class_ref (extension->type);
 649 }
 650
 651 /**
 652  * g_io_extension_get_type:
 653  * @extension: a #GIOExtension
 654  *
 655  * Gets the type associated with @extension.
 656  *
 657  * Returns: the type of @extension
 658  */
 659 GType
 660 g_io_extension_get_type (GIOExtension *extension)
 661 {
 662   return extension->type;
 663 }
 664
 665 /**
 666  * g_io_extension_get_name:
 667  * @extension: a #GIOExtension
 668  *
 669  * Gets the name under which @extension was registered.
 670  *
 671  * Note that the same type may be registered as extension
 672  * for multiple extension points, under different names.
 673  *
 674  * Returns: the name of @extension.
 675  */
 676 const char *
 677 g_io_extension_get_name (GIOExtension *extension)
 678 {
 679   return extension->name;
 680 }
 681
 682 /**
 683  * g_io_extension_get_priority:
 684  * @extension: a #GIOExtension
 685  *
 686  * Gets the priority with which @extension was registered.
 687  *
 688  * Returns: the priority of @extension
 689  */
 690 gint
 691 g_io_extension_get_priority (GIOExtension *extension)
 692 {
 693   return extension->priority;
 694 }
 695
 696 #define __G_IO_MODULE_C__
 697 #include "gioaliasdef.c"