gst/gstplugin.c

   1 /* GStreamer
   2  * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
   3  *                    2000 Wim Taymans <wtay@chello.be>
   4  *
   5  * gstplugin.c: Plugin subsystem for loading elements, types, and libs
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 /**
  24  * SECTION:gstplugin
  25  * @short_description: Container for features loaded from a shared object module
  26  * @see_also: #GstPluginFeature, #GstElementFactory
  27  *
  28  * GStreamer is extensible, so #GstElement instances can be loaded at runtime.
  29  * A plugin system can provide one or more of the basic
  30  * <application>GStreamer</application> #GstPluginFeature subclasses.
  31  *
  32  * A plugin should export a symbol <symbol>gst_plugin_desc</symbol> that is a
  33  * struct of type #GstPluginDesc.
  34  * the plugin loader will check the version of the core library the plugin was
  35  * linked against and will create a new #GstPlugin. It will then call the
  36  * #GstPluginInitFunc function that was provided in the
  37  * <symbol>gst_plugin_desc</symbol>.
  38  *
  39  * Once you have a handle to a #GstPlugin (e.g. from the #GstRegistry), you
  40  * can add any object that subclasses #GstPluginFeature.
  41  *
  42  * Usually plugins are always automaticlly loaded so you don't need to call
  43  * gst_plugin_load() explicitly to bring it into memory. There are options to
  44  * statically link plugins to an app or even use GStreamer without a plugin
  45  * repository in which case gst_plugin_load() can be needed to bring the plugin
  46  * into memory.
  47  */
  48
  49 #ifdef HAVE_CONFIG_H
  50 #include "config.h"
  51 #endif
  52
  53 #include "gst_private.h"
  54
  55 #include <glib/gstdio.h>
  56 #include <sys/types.h>
  57 #ifdef HAVE_DIRENT_H
  58 #include <dirent.h>
  59 #endif
  60 #ifdef HAVE_UNISTD_H
  61 #include <unistd.h>
  62 #endif
  63 #include <signal.h>
  64 #include <errno.h>
  65 #include <string.h>
  66
  67 #include "glib-compat-private.h"
  68
  69 #include <gst/gst.h>
  70
  71 #define GST_CAT_DEFAULT GST_CAT_PLUGIN_LOADING
  72
  73 static guint _num_static_plugins;       /* 0    */
  74 static GstPluginDesc *_static_plugins;  /* NULL */
  75 static gboolean _gst_plugin_inited;
  76 static gchar **_plugin_loading_whitelist;       /* NULL */
  77
  78 /* static variables for segfault handling of plugin loading */
  79 static char *_gst_plugin_fault_handler_filename = NULL;
  80
  81 /* list of valid licenses.
  82  * One of these must be specified or the plugin won't be loaded
  83  * Contact gstreamer-devel@lists.sourceforge.net if your license should be
  84  * added.
  85  *
  86  * GPL: http://www.gnu.org/copyleft/gpl.html
  87  * LGPL: http://www.gnu.org/copyleft/lesser.html
  88  * QPL: http://www.trolltech.com/licenses/qpl.html
  89  * MPL: http://www.opensource.org/licenses/mozilla1.1.php
  90  * MIT/X11: http://www.opensource.org/licenses/mit-license.php
  91  * 3-clause BSD: http://www.opensource.org/licenses/bsd-license.php
  92  */
  93 static const gchar *valid_licenses[] = {
  94   "LGPL",                       /* GNU Lesser General Public License */
  95   "GPL",                        /* GNU General Public License */
  96   "QPL",                        /* Trolltech Qt Public License */
  97   "GPL/QPL",                    /* Combi-license of GPL + QPL */
  98   "MPL",                        /* MPL 1.1 license */
  99   "BSD",                        /* 3-clause BSD license */
 100   "MIT/X11",                    /* MIT/X11 license */
 101   "Proprietary",                /* Proprietary license */
 102   GST_LICENSE_UNKNOWN,          /* some other license */
 103   NULL
 104 };
 105
 106 static GstPlugin *gst_plugin_register_func (GstPlugin * plugin,
 107     const GstPluginDesc * desc, gpointer user_data);
 108 static void gst_plugin_desc_copy (GstPluginDesc * dest,
 109     const GstPluginDesc * src);
 110
 111 static void gst_plugin_ext_dep_free (GstPluginDep * dep);
 112
 113 G_DEFINE_TYPE (GstPlugin, gst_plugin, GST_TYPE_OBJECT);
 114
 115 static void
 116 gst_plugin_init (GstPlugin * plugin)
 117 {
 118   plugin->priv =
 119       G_TYPE_INSTANCE_GET_PRIVATE (plugin, GST_TYPE_PLUGIN, GstPluginPrivate);
 120 }
 121
 122 static void
 123 gst_plugin_finalize (GObject * object)
 124 {
 125   GstPlugin *plugin = GST_PLUGIN_CAST (object);
 126   GstRegistry *registry = gst_registry_get_default ();
 127   GList *g;
 128
 129   GST_DEBUG ("finalizing plugin %" GST_PTR_FORMAT, plugin);
 130   for (g = registry->plugins; g; g = g->next) {
 131     if (g->data == (gpointer) plugin) {
 132       g_warning ("removing plugin that is still in registry");
 133     }
 134   }
 135   g_free (plugin->filename);
 136   g_free (plugin->basename);
 137
 138   g_list_foreach (plugin->priv->deps, (GFunc) gst_plugin_ext_dep_free, NULL);
 139   g_list_free (plugin->priv->deps);
 140   plugin->priv->deps = NULL;
 141
 142   if (plugin->priv->cache_data) {
 143     gst_structure_free (plugin->priv->cache_data);
 144   }
 145
 146   G_OBJECT_CLASS (gst_plugin_parent_class)->finalize (object);
 147 }
 148
 149 static void
 150 gst_plugin_class_init (GstPluginClass * klass)
 151 {
 152   G_OBJECT_CLASS (klass)->finalize = gst_plugin_finalize;
 153
 154   g_type_class_add_private (klass, sizeof (GstPluginPrivate));
 155 }
 156
 157 GQuark
 158 gst_plugin_error_quark (void)
 159 {
 160   static GQuark quark = 0;
 161
 162   if (!quark)
 163     quark = g_quark_from_static_string ("gst_plugin_error");
 164   return quark;
 165 }
 166
 167 #ifndef GST_REMOVE_DEPRECATED
 168 #ifdef GST_DISABLE_DEPRECATED
 169 void _gst_plugin_register_static (GstPluginDesc * desc);
 170 #endif
 171 /* this function can be called in the GCC constructor extension, before
 172  * the _gst_plugin_initialize() was called. In that case, we store the
 173  * plugin description in a list to initialize it when we open the main
 174  * module later on.
 175  * When the main module is known, we can register the plugin right away.
 176  */
 177 void
 178 _gst_plugin_register_static (GstPluginDesc * desc)
 179 {
 180   g_return_if_fail (desc != NULL);
 181
 182   if (!_gst_plugin_inited) {
 183     /* We can't use any GLib functions here, since g_thread_init hasn't been
 184      * called yet, and we can't call it here either, or programs that don't
 185      * guard their g_thread_init calls in main() will just abort */
 186     ++_num_static_plugins;
 187     _static_plugins =
 188         realloc (_static_plugins, _num_static_plugins * sizeof (GstPluginDesc));
 189     /* assume strings in the GstPluginDesc are static const or live forever */
 190     _static_plugins[_num_static_plugins - 1] = *desc;
 191   } else {
 192     gst_plugin_register_static (desc->major_version, desc->minor_version,
 193         desc->name, desc->description, desc->plugin_init, desc->version,
 194         desc->license, desc->source, desc->package, desc->origin);
 195   }
 196 }
 197 #endif
 198
 199 /**
 200  * gst_plugin_register_static:
 201  * @major_version: the major version number of the GStreamer core that the
 202  *     plugin was compiled for, you can just use GST_VERSION_MAJOR here
 203  * @minor_version: the minor version number of the GStreamer core that the
 204  *     plugin was compiled for, you can just use GST_VERSION_MINOR here
 205  * @name: a unique name of the plugin (ideally prefixed with an application- or
 206  *     library-specific namespace prefix in order to avoid name conflicts in
 207  *     case a similar plugin with the same name ever gets added to GStreamer)
 208  * @description: description of the plugin
 209  * @init_func: (scope call): pointer to the init function of this plugin.
 210  * @version: version string of the plugin
 211  * @license: effective license of plugin. Must be one of the approved licenses
 212  *     (see #GstPluginDesc above) or the plugin will not be registered.
 213  * @source: source module plugin belongs to
 214  * @package: shipped package plugin belongs to
 215  * @origin: URL to provider of plugin
 216  *
 217  * Registers a static plugin, ie. a plugin which is private to an application
 218  * or library and contained within the application or library (as opposed to
 219  * being shipped as a separate module file).
 220  *
 221  * You must make sure that GStreamer has been initialised (with gst_init() or
 222  * via gst_init_get_option_group()) before calling this function.
 223  *
 224  * Returns: TRUE if the plugin was registered correctly, otherwise FALSE.
 225  *
 226  * Since: 0.10.16
 227  */
 228 gboolean
 229 gst_plugin_register_static (gint major_version, gint minor_version,
 230     const gchar * name, const gchar * description, GstPluginInitFunc init_func,
 231     const gchar * version, const gchar * license, const gchar * source,
 232     const gchar * package, const gchar * origin)
 233 {
 234   GstPluginDesc desc = { major_version, minor_version, name, description,
 235     init_func, version, license, source, package, origin, NULL,
 236   };
 237   GstPlugin *plugin;
 238   gboolean res = FALSE;
 239
 240   g_return_val_if_fail (name != NULL, FALSE);
 241   g_return_val_if_fail (description != NULL, FALSE);
 242   g_return_val_if_fail (init_func != NULL, FALSE);
 243   g_return_val_if_fail (version != NULL, FALSE);
 244   g_return_val_if_fail (license != NULL, FALSE);
 245   g_return_val_if_fail (source != NULL, FALSE);
 246   g_return_val_if_fail (package != NULL, FALSE);
 247   g_return_val_if_fail (origin != NULL, FALSE);
 248
 249   /* make sure gst_init() has been called */
 250   g_return_val_if_fail (_gst_plugin_inited != FALSE, FALSE);
 251
 252   GST_LOG ("attempting to load static plugin \"%s\" now...", name);
 253   plugin = g_object_newv (GST_TYPE_PLUGIN, 0, NULL);
 254   if (gst_plugin_register_func (plugin, &desc, NULL) != NULL) {
 255     GST_INFO ("registered static plugin \"%s\"", name);
 256     res = gst_default_registry_add_plugin (plugin);
 257     GST_INFO ("added static plugin \"%s\", result: %d", name, res);
 258   }
 259   return res;
 260 }
 261
 262 /**
 263  * gst_plugin_register_static_full:
 264  * @major_version: the major version number of the GStreamer core that the
 265  *     plugin was compiled for, you can just use GST_VERSION_MAJOR here
 266  * @minor_version: the minor version number of the GStreamer core that the
 267  *     plugin was compiled for, you can just use GST_VERSION_MINOR here
 268  * @name: a unique name of the plugin (ideally prefixed with an application- or
 269  *     library-specific namespace prefix in order to avoid name conflicts in
 270  *     case a similar plugin with the same name ever gets added to GStreamer)
 271  * @description: description of the plugin
 272  * @init_full_func: (scope call): pointer to the init function with user data
 273  *     of this plugin.
 274  * @version: version string of the plugin
 275  * @license: effective license of plugin. Must be one of the approved licenses
 276  *     (see #GstPluginDesc above) or the plugin will not be registered.
 277  * @source: source module plugin belongs to
 278  * @package: shipped package plugin belongs to
 279  * @origin: URL to provider of plugin
 280  * @user_data: gpointer to user data
 281  *
 282  * Registers a static plugin, ie. a plugin which is private to an application
 283  * or library and contained within the application or library (as opposed to
 284  * being shipped as a separate module file) with a #GstPluginInitFullFunc
 285  * which allows user data to be passed to the callback function (useful
 286  * for bindings).
 287  *
 288  * You must make sure that GStreamer has been initialised (with gst_init() or
 289  * via gst_init_get_option_group()) before calling this function.
 290  *
 291  * Returns: TRUE if the plugin was registered correctly, otherwise FALSE.
 292  *
 293  * Since: 0.10.24
 294  *
 295  */
 296 gboolean
 297 gst_plugin_register_static_full (gint major_version, gint minor_version,
 298     const gchar * name, const gchar * description,
 299     GstPluginInitFullFunc init_full_func, const gchar * version,
 300     const gchar * license, const gchar * source, const gchar * package,
 301     const gchar * origin, gpointer user_data)
 302 {
 303   GstPluginDesc desc = { major_version, minor_version, name, description,
 304     (GstPluginInitFunc) init_full_func, version, license, source, package,
 305     origin, NULL,
 306   };
 307   GstPlugin *plugin;
 308   gboolean res = FALSE;
 309
 310   g_return_val_if_fail (name != NULL, FALSE);
 311   g_return_val_if_fail (description != NULL, FALSE);
 312   g_return_val_if_fail (init_full_func != NULL, FALSE);
 313   g_return_val_if_fail (version != NULL, FALSE);
 314   g_return_val_if_fail (license != NULL, FALSE);
 315   g_return_val_if_fail (source != NULL, FALSE);
 316   g_return_val_if_fail (package != NULL, FALSE);
 317   g_return_val_if_fail (origin != NULL, FALSE);
 318
 319   /* make sure gst_init() has been called */
 320   g_return_val_if_fail (_gst_plugin_inited != FALSE, FALSE);
 321
 322   GST_LOG ("attempting to load static plugin \"%s\" now...", name);
 323   plugin = g_object_newv (GST_TYPE_PLUGIN, 0, NULL);
 324   if (gst_plugin_register_func (plugin, &desc, user_data) != NULL) {
 325     GST_INFO ("registered static plugin \"%s\"", name);
 326     res = gst_default_registry_add_plugin (plugin);
 327     GST_INFO ("added static plugin \"%s\", result: %d", name, res);
 328   }
 329   return res;
 330 }
 331
 332 void
 333 _gst_plugin_initialize (void)
 334 {
 335   const gchar *whitelist;
 336   guint i;
 337
 338   _gst_plugin_inited = TRUE;
 339
 340   whitelist = g_getenv ("GST_PLUGIN_LOADING_WHITELIST");
 341   if (whitelist != NULL && *whitelist != '\0') {
 342     _plugin_loading_whitelist = g_strsplit (whitelist,
 343         G_SEARCHPATH_SEPARATOR_S, -1);
 344     for (i = 0; _plugin_loading_whitelist[i] != NULL; ++i) {
 345       GST_INFO ("plugins whitelist entry: %s", _plugin_loading_whitelist[i]);
 346     }
 347   }
 348
 349   /* now register all static plugins */
 350   GST_INFO ("registering %u static plugins", _num_static_plugins);
 351   for (i = 0; i < _num_static_plugins; ++i) {
 352     gst_plugin_register_static (_static_plugins[i].major_version,
 353         _static_plugins[i].minor_version, _static_plugins[i].name,
 354         _static_plugins[i].description, _static_plugins[i].plugin_init,
 355         _static_plugins[i].version, _static_plugins[i].license,
 356         _static_plugins[i].source, _static_plugins[i].package,
 357         _static_plugins[i].origin);
 358   }
 359
 360   if (_static_plugins) {
 361     free (_static_plugins);
 362     _static_plugins = NULL;
 363     _num_static_plugins = 0;
 364   }
 365 }
 366
 367 /* Whitelist entry format:
 368  *
 369  *   plugin1,plugin2@pathprefix or
 370  *   plugin1,plugin2@* or just
 371  *   plugin1,plugin2 or
 372  *   source-package@pathprefix or
 373  *   source-package@* or just
 374  *   source-package
 375  *
 376  * ie. the bit before the path will be checked against both the plugin
 377  * name and the plugin's source package name, to keep the format simple.
 378  */
 379 static gboolean
 380 gst_plugin_desc_matches_whitelist_entry (GstPluginDesc * desc,
 381     const gchar * filename, const gchar * pattern)
 382 {
 383   const gchar *sep;
 384   gboolean ret = FALSE;
 385   gchar *name;
 386
 387   GST_LOG ("Whitelist pattern '%s', plugin: %s of %s@%s", pattern, desc->name,
 388       desc->source, GST_STR_NULL (filename));
 389
 390   /* do we have a path prefix? */
 391   sep = strchr (pattern, '@');
 392   if (sep != NULL && strcmp (sep, "@*") != 0 && strcmp (sep, "@") != 0) {
 393     /* paths are not canonicalised or treated with realpath() here. This
 394      * should be good enough for our use case, since we just use the paths
 395      * autotools uses, and those will be constructed from the same prefix. */
 396     if (filename != NULL && !g_str_has_prefix (filename, sep + 1))
 397       return FALSE;
 398
 399     GST_LOG ("%s matches path prefix %s", GST_STR_NULL (filename), sep + 1);
 400   }
 401
 402   if (sep != NULL) {
 403     name = g_strndup (pattern, (gsize) (sep - pattern));
 404   } else {
 405     name = g_strdup (pattern);
 406   }
 407
 408   g_strstrip (name);
 409   if (!g_ascii_isalnum (*name)) {
 410     GST_WARNING ("Invalid whitelist pattern: %s", pattern);
 411     goto done;
 412   }
 413
 414   /* now check plugin names / source package name */
 415   if (strchr (name, ',') == NULL) {
 416     /* only a single name: either a plugin name or the source package name */
 417     ret = (strcmp (desc->source, name) == 0 || strcmp (desc->name, name) == 0);
 418   } else {
 419     gchar **n, **names;
 420
 421     /* multiple names: assume these are plugin names */
 422     names = g_strsplit (name, ",", -1);
 423     for (n = names; n != NULL && *n != NULL; ++n) {
 424       g_strstrip (*n);
 425       if (strcmp (desc->name, *n) == 0) {
 426         ret = TRUE;
 427         break;
 428       }
 429     }
 430     g_strfreev (names);
 431   }
 432
 433   GST_LOG ("plugin / source package name match: %d", ret);
 434
 435 done:
 436
 437   g_free (name);
 438   return ret;
 439 }
 440
 441 gboolean
 442 priv_gst_plugin_desc_is_whitelisted (GstPluginDesc * desc,
 443     const gchar * filename)
 444 {
 445   gchar **entry;
 446
 447   if (_plugin_loading_whitelist == NULL)
 448     return TRUE;
 449
 450   for (entry = _plugin_loading_whitelist; *entry != NULL; ++entry) {
 451     if (gst_plugin_desc_matches_whitelist_entry (desc, filename, *entry)) {
 452       GST_LOG ("Plugin %s is in whitelist", filename);
 453       return TRUE;
 454     }
 455   }
 456
 457   GST_LOG ("Plugin %s (package %s, file %s) not in whitelist", desc->name,
 458       desc->source, filename);
 459   return FALSE;
 460 }
 461
 462 gboolean
 463 priv_gst_plugin_loading_have_whitelist (void)
 464 {
 465   return (_plugin_loading_whitelist != NULL);
 466 }
 467
 468 guint32
 469 priv_gst_plugin_loading_get_whitelist_hash (void)
 470 {
 471   guint32 hash = 0;
 472
 473   if (_plugin_loading_whitelist != NULL) {
 474     gchar **w;
 475
 476     for (w = _plugin_loading_whitelist; *w != NULL; ++w)
 477       hash = (hash << 1) ^ g_str_hash (*w);
 478   }
 479
 480   return hash;
 481 }
 482
 483 /* this function could be extended to check if the plugin license matches the
 484  * applications license (would require the app to register its license somehow).
 485  * We'll wait for someone who's interested in it to code it :)
 486  */
 487 static gboolean
 488 gst_plugin_check_license (const gchar * license)
 489 {
 490   const gchar **check_license = valid_licenses;
 491
 492   g_assert (check_license);
 493
 494   while (*check_license) {
 495     if (strcmp (license, *check_license) == 0)
 496       return TRUE;
 497     check_license++;
 498   }
 499   return FALSE;
 500 }
 501
 502 static gboolean
 503 gst_plugin_check_version (gint major, gint minor)
 504 {
 505   /* return NULL if the major and minor version numbers are not compatible */
 506   /* with ours. */
 507   if (major != GST_VERSION_MAJOR || minor != GST_VERSION_MINOR)
 508     return FALSE;
 509
 510   return TRUE;
 511 }
 512
 513 static GstPlugin *
 514 gst_plugin_register_func (GstPlugin * plugin, const GstPluginDesc * desc,
 515     gpointer user_data)
 516 {
 517   if (!gst_plugin_check_version (desc->major_version, desc->minor_version)) {
 518     if (GST_CAT_DEFAULT)
 519       GST_WARNING ("plugin \"%s\" has incompatible version, not loading",
 520           plugin->filename);
 521     return NULL;
 522   }
 523
 524   if (!desc->license || !desc->description || !desc->source ||
 525       !desc->package || !desc->origin) {
 526     if (GST_CAT_DEFAULT)
 527       GST_WARNING ("plugin \"%s\" has incorrect GstPluginDesc, not loading",
 528           plugin->filename);
 529     return NULL;
 530   }
 531
 532   if (!gst_plugin_check_license (desc->license)) {
 533     if (GST_CAT_DEFAULT)
 534       GST_WARNING ("plugin \"%s\" has invalid license \"%s\", not loading",
 535           plugin->filename, desc->license);
 536     return NULL;
 537   }
 538
 539   if (GST_CAT_DEFAULT)
 540     GST_LOG ("plugin \"%s\" looks good", GST_STR_NULL (plugin->filename));
 541
 542   gst_plugin_desc_copy (&plugin->desc, desc);
 543
 544   /* make resident so we're really sure it never gets unloaded again.
 545    * Theoretically this is not needed, but practically it doesn't hurt.
 546    * And we're rather safe than sorry. */
 547   if (plugin->module)
 548     g_module_make_resident (plugin->module);
 549
 550   if (user_data) {
 551     if (!(((GstPluginInitFullFunc) (desc->plugin_init)) (plugin, user_data))) {
 552       if (GST_CAT_DEFAULT)
 553         GST_WARNING ("plugin \"%s\" failed to initialise", plugin->filename);
 554       return NULL;
 555     }
 556   } else {
 557     if (!((desc->plugin_init) (plugin))) {
 558       if (GST_CAT_DEFAULT)
 559         GST_WARNING ("plugin \"%s\" failed to initialise", plugin->filename);
 560       return NULL;
 561     }
 562   }
 563
 564   if (GST_CAT_DEFAULT)
 565     GST_LOG ("plugin \"%s\" initialised", GST_STR_NULL (plugin->filename));
 566
 567   return plugin;
 568 }
 569
 570 #ifdef HAVE_SIGACTION
 571 static struct sigaction oldaction;
 572 static gboolean _gst_plugin_fault_handler_is_setup = FALSE;
 573
 574 /*
 575  * _gst_plugin_fault_handler_restore:
 576  * segfault handler restorer
 577  */
 578 static void
 579 _gst_plugin_fault_handler_restore (void)
 580 {
 581   if (!_gst_plugin_fault_handler_is_setup)
 582     return;
 583
 584   _gst_plugin_fault_handler_is_setup = FALSE;
 585
 586   sigaction (SIGSEGV, &oldaction, NULL);
 587 }
 588
 589 /*
 590  * _gst_plugin_fault_handler_sighandler:
 591  * segfault handler implementation
 592  */
 593 static void
 594 _gst_plugin_fault_handler_sighandler (int signum)
 595 {
 596   /* We need to restore the fault handler or we'll keep getting it */
 597   _gst_plugin_fault_handler_restore ();
 598
 599   switch (signum) {
 600     case SIGSEGV:
 601       g_print ("\nERROR: ");
 602       g_print ("Caught a segmentation fault while loading plugin file:\n");
 603       g_print ("%s\n\n", _gst_plugin_fault_handler_filename);
 604       g_print ("Please either:\n");
 605       g_print ("- remove it and restart.\n");
 606       g_print
 607           ("- run with --gst-disable-segtrap --gst-disable-registry-fork and debug.\n");
 608       exit (-1);
 609       break;
 610     default:
 611       g_print ("Caught unhandled signal on plugin loading\n");
 612       break;
 613   }
 614 }
 615
 616 /*
 617  * _gst_plugin_fault_handler_setup:
 618  * sets up the segfault handler
 619  */
 620 static void
 621 _gst_plugin_fault_handler_setup (void)
 622 {
 623   struct sigaction action;
 624
 625   /* if asked to leave segfaults alone, just return */
 626   if (!gst_segtrap_is_enabled ())
 627     return;
 628
 629   if (_gst_plugin_fault_handler_is_setup)
 630     return;
 631
 632   _gst_plugin_fault_handler_is_setup = TRUE;
 633
 634   memset (&action, 0, sizeof (action));
 635   action.sa_handler = _gst_plugin_fault_handler_sighandler;
 636
 637   sigaction (SIGSEGV, &action, &oldaction);
 638 }
 639 #else /* !HAVE_SIGACTION */
 640 static void
 641 _gst_plugin_fault_handler_restore (void)
 642 {
 643 }
 644
 645 static void
 646 _gst_plugin_fault_handler_setup (void)
 647 {
 648 }
 649 #endif /* HAVE_SIGACTION */
 650
 651 /* g_time_val_from_iso8601() doesn't do quite what we want */
 652 static gboolean
 653 check_release_datetime (const gchar * date_time)
 654 {
 655   guint64 val;
 656
 657   /* we require YYYY-MM-DD or YYYY-MM-DDTHH:MMZ format */
 658   if (!g_ascii_isdigit (*date_time))
 659     return FALSE;
 660
 661   val = g_ascii_strtoull (date_time, (gchar **) & date_time, 10);
 662   if (val < 2000 || val > 2100 || *date_time != '-')
 663     return FALSE;
 664
 665   val = g_ascii_strtoull (date_time + 1, (gchar **) & date_time, 10);
 666   if (val == 0 || val > 12 || *date_time != '-')
 667     return FALSE;
 668
 669   val = g_ascii_strtoull (date_time + 1, (gchar **) & date_time, 10);
 670   if (val == 0 || val > 32)
 671     return FALSE;
 672
 673   /* end of string or date/time separator + HH:MMZ */
 674   if (*date_time == 'T' || *date_time == ' ') {
 675     val = g_ascii_strtoull (date_time + 1, (gchar **) & date_time, 10);
 676     if (val > 24 || *date_time != ':')
 677       return FALSE;
 678
 679     val = g_ascii_strtoull (date_time + 1, (gchar **) & date_time, 10);
 680     if (val > 59 || *date_time != 'Z')
 681       return FALSE;
 682
 683     ++date_time;
 684   }
 685
 686   return (*date_time == '\0');
 687 }
 688
 689 static GStaticMutex gst_plugin_loading_mutex = G_STATIC_MUTEX_INIT;
 690
 691 #define CHECK_PLUGIN_DESC_FIELD(desc,field,fn)                               \
 692   if (G_UNLIKELY ((desc)->field == NULL)) {                                  \
 693     GST_ERROR ("GstPluginDesc for '%s' has no %s", fn, G_STRINGIFY (field)); \
 694   }
 695
 696 /**
 697  * gst_plugin_load_file:
 698  * @filename: the plugin filename to load
 699  * @error: pointer to a NULL-valued GError
 700  *
 701  * Loads the given plugin and refs it.  Caller needs to unref after use.
 702  *
 703  * Returns: (transfer full): a reference to the existing loaded GstPlugin, a
 704  * reference to the newly-loaded GstPlugin, or NULL if an error occurred.
 705  */
 706 GstPlugin *
 707 gst_plugin_load_file (const gchar * filename, GError ** error)
 708 {
 709   GstPluginDesc *desc;
 710   GstPlugin *plugin;
 711   GModule *module;
 712   gboolean ret;
 713   gpointer ptr;
 714   GStatBuf file_status;
 715   GstRegistry *registry;
 716   gboolean new_plugin = TRUE;
 717   GModuleFlags flags;
 718
 719   g_return_val_if_fail (filename != NULL, NULL);
 720
 721   registry = gst_registry_get_default ();
 722   g_static_mutex_lock (&gst_plugin_loading_mutex);
 723
 724   plugin = gst_registry_lookup (registry, filename);
 725   if (plugin) {
 726     if (plugin->module) {
 727       /* already loaded */
 728       g_static_mutex_unlock (&gst_plugin_loading_mutex);
 729       return plugin;
 730     } else {
 731       /* load plugin and update fields */
 732       new_plugin = FALSE;
 733     }
 734   }
 735
 736   GST_CAT_DEBUG (GST_CAT_PLUGIN_LOADING, "attempt to load plugin \"%s\"",
 737       filename);
 738
 739   if (g_module_supported () == FALSE) {
 740     GST_CAT_DEBUG (GST_CAT_PLUGIN_LOADING, "module loading not supported");
 741     g_set_error (error,
 742         GST_PLUGIN_ERROR,
 743         GST_PLUGIN_ERROR_MODULE, "Dynamic loading not supported");
 744     goto return_error;
 745   }
 746
 747   if (g_stat (filename, &file_status)) {
 748     GST_CAT_DEBUG (GST_CAT_PLUGIN_LOADING, "problem accessing file");
 749     g_set_error (error,
 750         GST_PLUGIN_ERROR,
 751         GST_PLUGIN_ERROR_MODULE, "Problem accessing file %s: %s", filename,
 752         g_strerror (errno));
 753     goto return_error;
 754   }
 755
 756   flags = G_MODULE_BIND_LOCAL;
 757   /* libgstpython.so is the gst-python plugin loader. It needs to be loaded with
 758    * G_MODULE_BIND_LAZY.
 759    *
 760    * Ideally there should be a generic way for plugins to specify that they
 761    * need to be loaded with _LAZY.
 762    * */
 763   if (strstr (filename, "libgstpython"))
 764     flags |= G_MODULE_BIND_LAZY;
 765
 766   module = g_module_open (filename, flags);
 767   if (module == NULL) {
 768     GST_CAT_WARNING (GST_CAT_PLUGIN_LOADING, "module_open failed: %s",
 769         g_module_error ());
 770     g_set_error (error,
 771         GST_PLUGIN_ERROR, GST_PLUGIN_ERROR_MODULE, "Opening module failed: %s",
 772         g_module_error ());
 773     /* If we failed to open the shared object, then it's probably because a
 774      * plugin is linked against the wrong libraries. Print out an easy-to-see
 775      * message in this case. */
 776     g_warning ("Failed to load plugin '%s': %s", filename, g_module_error ());
 777     goto return_error;
 778   }
 779
 780   ret = g_module_symbol (module, "gst_plugin_desc", &ptr);
 781   if (!ret) {
 782     GST_DEBUG ("Could not find plugin entry point in \"%s\"", filename);
 783     g_set_error (error,
 784         GST_PLUGIN_ERROR,
 785         GST_PLUGIN_ERROR_MODULE,
 786         "File \"%s\" is not a GStreamer plugin", filename);
 787     g_module_close (module);
 788     goto return_error;
 789   }
 790
 791   desc = (GstPluginDesc *) ptr;
 792
 793   if (priv_gst_plugin_loading_have_whitelist () &&
 794       !priv_gst_plugin_desc_is_whitelisted (desc, filename)) {
 795     GST_INFO ("Whitelist specified and plugin not in whitelist, not loading: "
 796         "name=%s, package=%s, file=%s", desc->name, desc->source, filename);
 797     g_set_error (error, GST_PLUGIN_ERROR, GST_PLUGIN_ERROR_MODULE,
 798         "Not loading plugin file \"%s\", not in whitelist", filename);
 799     g_module_close (module);
 800     goto return_error;
 801   }
 802
 803   if (new_plugin) {
 804     plugin = g_object_newv (GST_TYPE_PLUGIN, 0, NULL);
 805     plugin->file_mtime = file_status.st_mtime;
 806     plugin->file_size = file_status.st_size;
 807     plugin->filename = g_strdup (filename);
 808     plugin->basename = g_path_get_basename (filename);
 809   }
 810
 811   plugin->module = module;
 812   plugin->orig_desc = desc;
 813
 814   if (new_plugin) {
 815     /* check plugin description: complain about bad values but accept them, to
 816      * maintain backwards compatibility (FIXME: 0.11) */
 817     CHECK_PLUGIN_DESC_FIELD (plugin->orig_desc, name, filename);
 818     CHECK_PLUGIN_DESC_FIELD (plugin->orig_desc, description, filename);
 819     CHECK_PLUGIN_DESC_FIELD (plugin->orig_desc, version, filename);
 820     CHECK_PLUGIN_DESC_FIELD (plugin->orig_desc, license, filename);
 821     CHECK_PLUGIN_DESC_FIELD (plugin->orig_desc, source, filename);
 822     CHECK_PLUGIN_DESC_FIELD (plugin->orig_desc, package, filename);
 823     CHECK_PLUGIN_DESC_FIELD (plugin->orig_desc, origin, filename);
 824
 825     if (plugin->orig_desc->release_datetime != NULL &&
 826         !check_release_datetime (plugin->orig_desc->release_datetime)) {
 827       GST_ERROR ("GstPluginDesc for '%s' has invalid datetime '%s'",
 828           filename, plugin->orig_desc->release_datetime);
 829       plugin->orig_desc->release_datetime = NULL;
 830     }
 831   }
 832
 833   GST_LOG ("Plugin %p for file \"%s\" prepared, calling entry function...",
 834       plugin, filename);
 835
 836   /* this is where we load the actual .so, so let's trap SIGSEGV */
 837   _gst_plugin_fault_handler_setup ();
 838   _gst_plugin_fault_handler_filename = plugin->filename;
 839
 840   GST_LOG ("Plugin %p for file \"%s\" prepared, registering...",
 841       plugin, filename);
 842
 843   if (!gst_plugin_register_func (plugin, plugin->orig_desc, NULL)) {
 844     /* remove signal handler */
 845     _gst_plugin_fault_handler_restore ();
 846     GST_DEBUG ("gst_plugin_register_func failed for plugin \"%s\"", filename);
 847     /* plugin == NULL */
 848     g_set_error (error,
 849         GST_PLUGIN_ERROR,
 850         GST_PLUGIN_ERROR_MODULE,
 851         "File \"%s\" appears to be a GStreamer plugin, but it failed to initialize",
 852         filename);
 853     goto return_error;
 854   }
 855
 856   /* remove signal handler */
 857   _gst_plugin_fault_handler_restore ();
 858   _gst_plugin_fault_handler_filename = NULL;
 859   GST_INFO ("plugin \"%s\" loaded", plugin->filename);
 860
 861   if (new_plugin) {
 862     gst_object_ref (plugin);
 863     gst_default_registry_add_plugin (plugin);
 864   }
 865
 866   g_static_mutex_unlock (&gst_plugin_loading_mutex);
 867   return plugin;
 868
 869 return_error:
 870   {
 871     if (plugin)
 872       gst_object_unref (plugin);
 873     g_static_mutex_unlock (&gst_plugin_loading_mutex);
 874     return NULL;
 875   }
 876 }
 877
 878 static void
 879 gst_plugin_desc_copy (GstPluginDesc * dest, const GstPluginDesc * src)
 880 {
 881   dest->major_version = src->major_version;
 882   dest->minor_version = src->minor_version;
 883   dest->name = g_intern_string (src->name);
 884   dest->description = g_intern_string (src->description);
 885   dest->plugin_init = src->plugin_init;
 886   dest->version = g_intern_string (src->version);
 887   dest->license = g_intern_string (src->license);
 888   dest->source = g_intern_string (src->source);
 889   dest->package = g_intern_string (src->package);
 890   dest->origin = g_intern_string (src->origin);
 891   dest->release_datetime = g_intern_string (src->release_datetime);
 892 }
 893
 894 /**
 895  * gst_plugin_get_name:
 896  * @plugin: plugin to get the name of
 897  *
 898  * Get the short name of the plugin
 899  *
 900  * Returns: the name of the plugin
 901  */
 902 const gchar *
 903 gst_plugin_get_name (GstPlugin * plugin)
 904 {
 905   g_return_val_if_fail (plugin != NULL, NULL);
 906
 907   return plugin->desc.name;
 908 }
 909
 910 /**
 911  * gst_plugin_get_description:
 912  * @plugin: plugin to get long name of
 913  *
 914  * Get the long descriptive name of the plugin
 915  *
 916  * Returns: the long name of the plugin
 917  */
 918 const gchar *
 919 gst_plugin_get_description (GstPlugin * plugin)
 920 {
 921   g_return_val_if_fail (plugin != NULL, NULL);
 922
 923   return plugin->desc.description;
 924 }
 925
 926 /**
 927  * gst_plugin_get_filename:
 928  * @plugin: plugin to get the filename of
 929  *
 930  * get the filename of the plugin
 931  *
 932  * Returns: the filename of the plugin
 933  */
 934 const gchar *
 935 gst_plugin_get_filename (GstPlugin * plugin)
 936 {
 937   g_return_val_if_fail (plugin != NULL, NULL);
 938
 939   return plugin->filename;
 940 }
 941
 942 /**
 943  * gst_plugin_get_version:
 944  * @plugin: plugin to get the version of
 945  *
 946  * get the version of the plugin
 947  *
 948  * Returns: the version of the plugin
 949  */
 950 const gchar *
 951 gst_plugin_get_version (GstPlugin * plugin)
 952 {
 953   g_return_val_if_fail (plugin != NULL, NULL);
 954
 955   return plugin->desc.version;
 956 }
 957
 958 /**
 959  * gst_plugin_get_license:
 960  * @plugin: plugin to get the license of
 961  *
 962  * get the license of the plugin
 963  *
 964  * Returns: the license of the plugin
 965  */
 966 const gchar *
 967 gst_plugin_get_license (GstPlugin * plugin)
 968 {
 969   g_return_val_if_fail (plugin != NULL, NULL);
 970
 971   return plugin->desc.license;
 972 }
 973
 974 /**
 975  * gst_plugin_get_source:
 976  * @plugin: plugin to get the source of
 977  *
 978  * get the source module the plugin belongs to.
 979  *
 980  * Returns: the source of the plugin
 981  */
 982 const gchar *
 983 gst_plugin_get_source (GstPlugin * plugin)
 984 {
 985   g_return_val_if_fail (plugin != NULL, NULL);
 986
 987   return plugin->desc.source;
 988 }
 989
 990 /**
 991  * gst_plugin_get_package:
 992  * @plugin: plugin to get the package of
 993  *
 994  * get the package the plugin belongs to.
 995  *
 996  * Returns: the package of the plugin
 997  */
 998 const gchar *
 999 gst_plugin_get_package (GstPlugin * plugin)
1000 {
1001   g_return_val_if_fail (plugin != NULL, NULL);
1002
1003   return plugin->desc.package;
1004 }
1005
1006 /**
1007  * gst_plugin_get_origin:
1008  * @plugin: plugin to get the origin of
1009  *
1010  * get the URL where the plugin comes from
1011  *
1012  * Returns: the origin of the plugin
1013  */
1014 const gchar *
1015 gst_plugin_get_origin (GstPlugin * plugin)
1016 {
1017   g_return_val_if_fail (plugin != NULL, NULL);
1018
1019   return plugin->desc.origin;
1020 }
1021
1022 /**
1023  * gst_plugin_get_module:
1024  * @plugin: plugin to query
1025  *
1026  * Gets the #GModule of the plugin. If the plugin isn't loaded yet, NULL is
1027  * returned.
1028  *
1029  * Returns: (transfer none): module belonging to the plugin or NULL if the
1030  *          plugin isn't loaded yet.
1031  */
1032 GModule *
1033 gst_plugin_get_module (GstPlugin * plugin)
1034 {
1035   g_return_val_if_fail (plugin != NULL, NULL);
1036
1037   return plugin->module;
1038 }
1039
1040 /**
1041  * gst_plugin_is_loaded:
1042  * @plugin: plugin to query
1043  *
1044  * queries if the plugin is loaded into memory
1045  *
1046  * Returns: TRUE is loaded, FALSE otherwise
1047  */
1048 gboolean
1049 gst_plugin_is_loaded (GstPlugin * plugin)
1050 {
1051   g_return_val_if_fail (plugin != NULL, FALSE);
1052
1053   return (plugin->module != NULL || plugin->filename == NULL);
1054 }
1055
1056 /**
1057  * gst_plugin_get_cache_data:
1058  * @plugin: a plugin
1059  *
1060  * Gets the plugin specific data cache. If it is %NULL there is no cached data
1061  * stored. This is the case when the registry is getting rebuilt.
1062  *
1063  * Returns: (transfer none): The cached data as a #GstStructure or %NULL.
1064  *
1065  * Since: 0.10.24
1066  */
1067 const GstStructure *
1068 gst_plugin_get_cache_data (GstPlugin * plugin)
1069 {
1070   g_return_val_if_fail (GST_IS_PLUGIN (plugin), NULL);
1071
1072   return plugin->priv->cache_data;
1073 }
1074
1075 /**
1076  * gst_plugin_set_cache_data:
1077  * @plugin: a plugin
1078  * @cache_data: (transfer full): a structure containing the data to cache
1079  *
1080  * Adds plugin specific data to cache. Passes the ownership of the structure to
1081  * the @plugin.
1082  *
1083  * The cache is flushed every time the registry is rebuilt.
1084  *
1085  * Since: 0.10.24
1086  */
1087 void
1088 gst_plugin_set_cache_data (GstPlugin * plugin, GstStructure * cache_data)
1089 {
1090   g_return_if_fail (GST_IS_PLUGIN (plugin));
1091   g_return_if_fail (GST_IS_STRUCTURE (cache_data));
1092
1093   if (plugin->priv->cache_data) {
1094     gst_structure_free (plugin->priv->cache_data);
1095   }
1096   plugin->priv->cache_data = cache_data;
1097 }
1098
1099 #if 0
1100 /**
1101  * gst_plugin_feature_list:
1102  * @plugin: plugin to query
1103  * @filter: the filter to use
1104  * @first: only return first match
1105  * @user_data: user data passed to the filter function
1106  *
1107  * Runs a filter against all plugin features and returns a GList with
1108  * the results. If the first flag is set, only the first match is
1109  * returned (as a list with a single object).
1110  *
1111  * Returns: a GList of features, g_list_free after use.
1112  */
1113 GList *
1114 gst_plugin_feature_filter (GstPlugin * plugin,
1115     GstPluginFeatureFilter filter, gboolean first, gpointer user_data)
1116 {
1117   GList *list;
1118   GList *g;
1119
1120   list = gst_filter_run (plugin->features, (GstFilterFunc) filter, first,
1121       user_data);
1122   for (g = list; g; g = g->next) {
1123     gst_object_ref (plugin);
1124   }
1125
1126   return list;
1127 }
1128
1129 typedef struct
1130 {
1131   GstPluginFeatureFilter filter;
1132   gboolean first;
1133   gpointer user_data;
1134   GList *result;
1135 }
1136 FeatureFilterData;
1137
1138 static gboolean
1139 _feature_filter (GstPlugin * plugin, gpointer user_data)
1140 {
1141   GList *result;
1142   FeatureFilterData *data = (FeatureFilterData *) user_data;
1143
1144   result = gst_plugin_feature_filter (plugin, data->filter, data->first,
1145       data->user_data);
1146   if (result) {
1147     data->result = g_list_concat (data->result, result);
1148     return TRUE;
1149   }
1150   return FALSE;
1151 }
1152
1153 /**
1154  * gst_plugin_list_feature_filter:
1155  * @list: a #GList of plugins to query
1156  * @filter: the filter function to use
1157  * @first: only return first match
1158  * @user_data: user data passed to the filter function
1159  *
1160  * Runs a filter against all plugin features of the plugins in the given
1161  * list and returns a GList with the results.
1162  * If the first flag is set, only the first match is
1163  * returned (as a list with a single object).
1164  *
1165  * Returns: a GList of features, g_list_free after use.
1166  */
1167 GList *
1168 gst_plugin_list_feature_filter (GList * list,
1169     GstPluginFeatureFilter filter, gboolean first, gpointer user_data)
1170 {
1171   FeatureFilterData data;
1172   GList *result;
1173
1174   data.filter = filter;
1175   data.first = first;
1176   data.user_data = user_data;
1177   data.result = NULL;
1178
1179   result = gst_filter_run (list, (GstFilterFunc) _feature_filter, first, &data);
1180   g_list_free (result);
1181
1182   return data.result;
1183 }
1184 #endif
1185
1186 /**
1187  * gst_plugin_name_filter:
1188  * @plugin: the plugin to check
1189  * @name: the name of the plugin
1190  *
1191  * A standard filter that returns TRUE when the plugin is of the
1192  * given name.
1193  *
1194  * Returns: TRUE if the plugin is of the given name.
1195  */
1196 gboolean
1197 gst_plugin_name_filter (GstPlugin * plugin, const gchar * name)
1198 {
1199   return (plugin->desc.name && !strcmp (plugin->desc.name, name));
1200 }
1201
1202 #if 0
1203 /**
1204  * gst_plugin_find_feature:
1205  * @plugin: plugin to get the feature from
1206  * @name: The name of the feature to find
1207  * @type: The type of the feature to find
1208  *
1209  * Find a feature of the given name and type in the given plugin.
1210  *
1211  * Returns: a GstPluginFeature or NULL if the feature was not found.
1212  */
1213 GstPluginFeature *
1214 gst_plugin_find_feature (GstPlugin * plugin, const gchar * name, GType type)
1215 {
1216   GList *walk;
1217   GstPluginFeature *result = NULL;
1218   GstTypeNameData data;
1219
1220   g_return_val_if_fail (name != NULL, NULL);
1221
1222   data.type = type;
1223   data.name = name;
1224
1225   walk = gst_filter_run (plugin->features,
1226       (GstFilterFunc) gst_plugin_feature_type_name_filter, TRUE, &data);
1227
1228   if (walk) {
1229     result = GST_PLUGIN_FEATURE (walk->data);
1230
1231     gst_object_ref (result);
1232     gst_plugin_feature_list_free (walk);
1233   }
1234
1235   return result;
1236 }
1237 #endif
1238
1239 #if 0
1240 static gboolean
1241 gst_plugin_feature_name_filter (GstPluginFeature * feature, const gchar * name)
1242 {
1243   return !strcmp (name, GST_PLUGIN_FEATURE_NAME (feature));
1244 }
1245 #endif
1246
1247 #if 0
1248 /**
1249  * gst_plugin_find_feature_by_name:
1250  * @plugin: plugin to get the feature from
1251  * @name: The name of the feature to find
1252  *
1253  * Find a feature of the given name in the given plugin.
1254  *
1255  * Returns: a GstPluginFeature or NULL if the feature was not found.
1256  */
1257 GstPluginFeature *
1258 gst_plugin_find_feature_by_name (GstPlugin * plugin, const gchar * name)
1259 {
1260   GList *walk;
1261   GstPluginFeature *result = NULL;
1262
1263   g_return_val_if_fail (name != NULL, NULL);
1264
1265   walk = gst_filter_run (plugin->features,
1266       (GstFilterFunc) gst_plugin_feature_name_filter, TRUE, (void *) name);
1267
1268   if (walk) {
1269     result = GST_PLUGIN_FEATURE (walk->data);
1270
1271     gst_object_ref (result);
1272     gst_plugin_feature_list_free (walk);
1273   }
1274
1275   return result;
1276 }
1277 #endif
1278
1279 /**
1280  * gst_plugin_load_by_name:
1281  * @name: name of plugin to load
1282  *
1283  * Load the named plugin. Refs the plugin.
1284  *
1285  * Returns: (transfer full): a reference to a loaded plugin, or NULL on error.
1286  */
1287 GstPlugin *
1288 gst_plugin_load_by_name (const gchar * name)
1289 {
1290   GstPlugin *plugin, *newplugin;
1291   GError *error = NULL;
1292
1293   GST_DEBUG ("looking up plugin %s in default registry", name);
1294   plugin = gst_registry_find_plugin (gst_registry_get_default (), name);
1295   if (plugin) {
1296     GST_DEBUG ("loading plugin %s from file %s", name, plugin->filename);
1297     newplugin = gst_plugin_load_file (plugin->filename, &error);
1298     gst_object_unref (plugin);
1299
1300     if (!newplugin) {
1301       GST_WARNING ("load_plugin error: %s", error->message);
1302       g_error_free (error);
1303       return NULL;
1304     }
1305     /* newplugin was reffed by load_file */
1306     return newplugin;
1307   }
1308
1309   GST_DEBUG ("Could not find plugin %s in registry", name);
1310   return NULL;
1311 }
1312
1313 /**
1314  * gst_plugin_load:
1315  * @plugin: (transfer none): plugin to load
1316  *
1317  * Loads @plugin. Note that the *return value* is the loaded plugin; @plugin is
1318  * untouched. The normal use pattern of this function goes like this:
1319  *
1320  * <programlisting>
1321  * GstPlugin *loaded_plugin;
1322  * loaded_plugin = gst_plugin_load (plugin);
1323  * // presumably, we're no longer interested in the potentially-unloaded plugin
1324  * gst_object_unref (plugin);
1325  * plugin = loaded_plugin;
1326  * </programlisting>
1327  *
1328  * Returns: (transfer full): a reference to a loaded plugin, or NULL on error.
1329  */
1330 GstPlugin *
1331 gst_plugin_load (GstPlugin * plugin)
1332 {
1333   GError *error = NULL;
1334   GstPlugin *newplugin;
1335
1336   if (gst_plugin_is_loaded (plugin)) {
1337     return plugin;
1338   }
1339
1340   if (!(newplugin = gst_plugin_load_file (plugin->filename, &error)))
1341     goto load_error;
1342
1343   return newplugin;
1344
1345 load_error:
1346   {
1347     GST_WARNING ("load_plugin error: %s", error->message);
1348     g_error_free (error);
1349     return NULL;
1350   }
1351 }
1352
1353 /**
1354  * gst_plugin_list_free:
1355  * @list: (transfer full) (element-type Gst.Plugin): list of #GstPlugin
1356  *
1357  * Unrefs each member of @list, then frees the list.
1358  */
1359 void
1360 gst_plugin_list_free (GList * list)
1361 {
1362   GList *g;
1363
1364   for (g = list; g; g = g->next) {
1365     gst_object_unref (GST_PLUGIN_CAST (g->data));
1366   }
1367   g_list_free (list);
1368 }
1369
1370 /* ===== plugin dependencies ===== */
1371
1372 /* Scenarios:
1373  * ENV + xyz     where ENV can contain multiple values separated by SEPARATOR
1374  *               xyz may be "" (if ENV contains path to file rather than dir)
1375  * ENV + *xyz   same as above, but xyz acts as suffix filter
1376  * ENV + xyz*   same as above, but xyz acts as prefix filter (is this needed?)
1377  * ENV + *xyz*  same as above, but xyz acts as strstr filter (is this needed?)
1378  *
1379  * same as above, with additional paths hard-coded at compile-time:
1380  *   - only check paths + ... if ENV is not set or yields not paths
1381  *   - always check paths + ... in addition to ENV
1382  *
1383  * When user specifies set of environment variables, he/she may also use e.g.
1384  * "HOME/.mystuff/plugins", and we'll expand the content of $HOME with the
1385  * remainder
1386  */
1387
1388 /* we store in registry:
1389  *  sets of:
1390  *   {
1391  *     - environment variables (array of strings)
1392  *     - last hash of env variable contents (uint) (so we can avoid doing stats
1393  *       if one of the env vars has changed; premature optimisation galore)
1394  *     - hard-coded paths (array of strings)
1395  *     - xyz filename/suffix/prefix strings (array of strings)
1396  *     - flags (int)
1397  *     - last hash of file/dir stats (int)
1398  *   }
1399  *   (= struct GstPluginDep)
1400  */
1401
1402 static guint
1403 gst_plugin_ext_dep_get_env_vars_hash (GstPlugin * plugin, GstPluginDep * dep)
1404 {
1405   gchar **e;
1406   guint hash;
1407
1408   /* there's no deeper logic to what we do here; all we want to know (when
1409    * checking if the plugin needs to be rescanned) is whether the content of
1410    * one of the environment variables in the list is different from when it
1411    * was last scanned */
1412   hash = 0;
1413   for (e = dep->env_vars; e != NULL && *e != NULL; ++e) {
1414     const gchar *val;
1415     gchar env_var[256];
1416
1417     /* order matters: "val",NULL needs to yield a different hash than
1418      * NULL,"val", so do a shift here whether the var is set or not */
1419     hash = hash << 5;
1420
1421     /* want environment variable at beginning of string */
1422     if (!g_ascii_isalnum (**e)) {
1423       GST_WARNING_OBJECT (plugin, "string prefix is not a valid environment "
1424           "variable string: %s", *e);
1425       continue;
1426     }
1427
1428     /* user is allowed to specify e.g. "HOME/.pitivi/plugins" */
1429     g_strlcpy (env_var, *e, sizeof (env_var));
1430     g_strdelimit (env_var, "/\\", '\0');
1431
1432     if ((val = g_getenv (env_var)))
1433       hash += g_str_hash (val);
1434   }
1435
1436   return hash;
1437 }
1438
1439 gboolean
1440 _priv_plugin_deps_env_vars_changed (GstPlugin * plugin)
1441 {
1442   GList *l;
1443
1444   for (l = plugin->priv->deps; l != NULL; l = l->next) {
1445     GstPluginDep *dep = l->data;
1446
1447     if (dep->env_hash != gst_plugin_ext_dep_get_env_vars_hash (plugin, dep))
1448       return TRUE;
1449   }
1450
1451   return FALSE;
1452 }
1453
1454 static GList *
1455 gst_plugin_ext_dep_extract_env_vars_paths (GstPlugin * plugin,
1456     GstPluginDep * dep)
1457 {
1458   gchar **evars;
1459   GList *paths = NULL;
1460
1461   for (evars = dep->env_vars; evars != NULL && *evars != NULL; ++evars) {
1462     const gchar *e;
1463     gchar **components;
1464
1465     /* want environment variable at beginning of string */
1466     if (!g_ascii_isalnum (**evars)) {
1467       GST_WARNING_OBJECT (plugin, "string prefix is not a valid environment "
1468           "variable string: %s", *evars);
1469       continue;
1470     }
1471
1472     /* user is allowed to specify e.g. "HOME/.pitivi/plugins", which we want to
1473      * split into the env_var name component and the path component */
1474     components = g_strsplit_set (*evars, "/\\", 2);
1475     g_assert (components != NULL);
1476
1477     e = g_getenv (components[0]);
1478     GST_LOG_OBJECT (plugin, "expanding %s = '%s' (path suffix: %s)",
1479         components[0], GST_STR_NULL (e), GST_STR_NULL (components[1]));
1480
1481     if (components[1] != NULL) {
1482       g_strdelimit (components[1], "/\\", G_DIR_SEPARATOR);
1483     }
1484
1485     if (e != NULL && *e != '\0') {
1486       gchar **arr;
1487       guint i;
1488
1489       arr = g_strsplit (e, G_SEARCHPATH_SEPARATOR_S, -1);
1490
1491       for (i = 0; arr != NULL && arr[i] != NULL; ++i) {
1492         gchar *full_path;
1493
1494         if (!g_path_is_absolute (arr[i])) {
1495           GST_INFO_OBJECT (plugin, "ignoring environment variable content '%s'"
1496               ": either not an absolute path or not a path at all", arr[i]);
1497           continue;
1498         }
1499
1500         if (components[1] != NULL) {
1501           full_path = g_build_filename (arr[i], components[1], NULL);
1502         } else {
1503           full_path = g_strdup (arr[i]);
1504         }
1505
1506         if (!g_list_find_custom (paths, full_path, (GCompareFunc) strcmp)) {
1507           GST_LOG_OBJECT (plugin, "path: '%s'", full_path);
1508           paths = g_list_prepend (paths, full_path);
1509           full_path = NULL;
1510         } else {
1511           GST_LOG_OBJECT (plugin, "path: '%s' (duplicate,ignoring)", full_path);
1512           g_free (full_path);
1513         }
1514       }
1515
1516       g_strfreev (arr);
1517     }
1518
1519     g_strfreev (components);
1520   }
1521
1522   GST_LOG_OBJECT (plugin, "Extracted %d paths from environment",
1523       g_list_length (paths));
1524
1525   return paths;
1526 }
1527
1528 static guint
1529 gst_plugin_ext_dep_get_hash_from_stat_entry (GStatBuf * s)
1530 {
1531   if (!(s->st_mode & (S_IFDIR | S_IFREG)))
1532     return (guint) - 1;
1533
1534   /* completely random formula */
1535   return ((s->st_size << 3) + (s->st_mtime << 5)) ^ s->st_ctime;
1536 }
1537
1538 static gboolean
1539 gst_plugin_ext_dep_direntry_matches (GstPlugin * plugin, const gchar * entry,
1540     const gchar ** filenames, GstPluginDependencyFlags flags)
1541 {
1542   /* no filenames specified, match all entries for now (could probably
1543    * optimise by just taking the dir stat hash or so) */
1544   if (filenames == NULL || *filenames == NULL || **filenames == '\0')
1545     return TRUE;
1546
1547   while (*filenames != NULL) {
1548     /* suffix match? */
1549     if (((flags & GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_SUFFIX)) &&
1550         g_str_has_suffix (entry, *filenames)) {
1551       return TRUE;
1552       /* else it's an exact match that's needed */
1553     } else if (strcmp (entry, *filenames) == 0) {
1554       return TRUE;
1555     }
1556     GST_LOG ("%s does not match %s, flags=0x%04x", entry, *filenames, flags);
1557     ++filenames;
1558   }
1559   return FALSE;
1560 }
1561
1562 static guint
1563 gst_plugin_ext_dep_scan_dir_and_match_names (GstPlugin * plugin,
1564     const gchar * path, const gchar ** filenames,
1565     GstPluginDependencyFlags flags, int depth)
1566 {
1567   const gchar *entry;
1568   gboolean recurse_dirs;
1569   GError *err = NULL;
1570   GDir *dir;
1571   guint hash = 0;
1572
1573   recurse_dirs = ! !(flags & GST_PLUGIN_DEPENDENCY_FLAG_RECURSE);
1574
1575   dir = g_dir_open (path, 0, &err);
1576   if (dir == NULL) {
1577     GST_DEBUG_OBJECT (plugin, "g_dir_open(%s) failed: %s", path, err->message);
1578     g_error_free (err);
1579     return (guint) - 1;
1580   }
1581
1582   /* FIXME: we're assuming here that we always get the directory entries in
1583    * the same order, and not in a random order */
1584   while ((entry = g_dir_read_name (dir))) {
1585     gboolean have_match;
1586     GStatBuf s;
1587     gchar *full_path;
1588     guint fhash;
1589
1590     have_match =
1591         gst_plugin_ext_dep_direntry_matches (plugin, entry, filenames, flags);
1592
1593     /* avoid the stat if possible */
1594     if (!have_match && !recurse_dirs)
1595       continue;
1596
1597     full_path = g_build_filename (path, entry, NULL);
1598     if (g_stat (full_path, &s) < 0) {
1599       fhash = (guint) - 1;
1600       GST_LOG_OBJECT (plugin, "stat: %s (error: %s)", full_path,
1601           g_strerror (errno));
1602     } else if (have_match) {
1603       fhash = gst_plugin_ext_dep_get_hash_from_stat_entry (&s);
1604       GST_LOG_OBJECT (plugin, "stat: %s (result: %u)", full_path, fhash);
1605     } else if ((s.st_mode & (S_IFDIR))) {
1606       fhash = gst_plugin_ext_dep_scan_dir_and_match_names (plugin, full_path,
1607           filenames, flags, depth + 1);
1608     } else {
1609       /* it's not a name match, we want to recurse, but it's not a directory */
1610       g_free (full_path);
1611       continue;
1612     }
1613
1614     hash = (hash + fhash) << 1;
1615     g_free (full_path);
1616   }
1617
1618   g_dir_close (dir);
1619   return hash;
1620 }
1621
1622 static guint
1623 gst_plugin_ext_dep_scan_path_with_filenames (GstPlugin * plugin,
1624     const gchar * path, const gchar ** filenames,
1625     GstPluginDependencyFlags flags)
1626 {
1627   const gchar *empty_filenames[] = { "", NULL };
1628   gboolean recurse_into_dirs, partial_names;
1629   guint i, hash = 0;
1630
1631   /* to avoid special-casing below (FIXME?) */
1632   if (filenames == NULL || *filenames == NULL)
1633     filenames = empty_filenames;
1634
1635   recurse_into_dirs = ! !(flags & GST_PLUGIN_DEPENDENCY_FLAG_RECURSE);
1636   partial_names = ! !(flags & GST_PLUGIN_DEPENDENCY_FLAG_FILE_NAME_IS_SUFFIX);
1637
1638   /* if we can construct the exact paths to check with the data we have, just
1639    * stat them one by one; this is more efficient than opening the directory
1640    * and going through each entry to see if it matches one of our filenames. */
1641   if (!recurse_into_dirs && !partial_names) {
1642     for (i = 0; filenames[i] != NULL; ++i) {
1643       GStatBuf s;
1644       gchar *full_path;
1645       guint fhash;
1646
1647       full_path = g_build_filename (path, filenames[i], NULL);
1648       if (g_stat (full_path, &s) < 0) {
1649         fhash = (guint) - 1;
1650         GST_LOG_OBJECT (plugin, "stat: %s (error: %s)", full_path,
1651             g_strerror (errno));
1652       } else {
1653         fhash = gst_plugin_ext_dep_get_hash_from_stat_entry (&s);
1654         GST_LOG_OBJECT (plugin, "stat: %s (result: %08x)", full_path, fhash);
1655       }
1656       hash = (hash + fhash) << 1;
1657       g_free (full_path);
1658     }
1659   } else {
1660     hash = gst_plugin_ext_dep_scan_dir_and_match_names (plugin, path,
1661         filenames, flags, 0);
1662   }
1663
1664   return hash;
1665 }
1666
1667 static guint
1668 gst_plugin_ext_dep_get_stat_hash (GstPlugin * plugin, GstPluginDep * dep)
1669 {
1670   gboolean paths_are_default_only;
1671   GList *scan_paths;
1672   guint scan_hash = 0;
1673
1674   GST_LOG_OBJECT (plugin, "start");
1675
1676   paths_are_default_only =
1677       dep->flags & GST_PLUGIN_DEPENDENCY_FLAG_PATHS_ARE_DEFAULT_ONLY;
1678
1679   scan_paths = gst_plugin_ext_dep_extract_env_vars_paths (plugin, dep);
1680
1681   if (scan_paths == NULL || !paths_are_default_only) {
1682     gchar **paths;
1683
1684     for (paths = dep->paths; paths != NULL && *paths != NULL; ++paths) {
1685       const gchar *path = *paths;
1686
1687       if (!g_list_find_custom (scan_paths, path, (GCompareFunc) strcmp)) {
1688         GST_LOG_OBJECT (plugin, "path: '%s'", path);
1689         scan_paths = g_list_prepend (scan_paths, g_strdup (path));
1690       } else {
1691         GST_LOG_OBJECT (plugin, "path: '%s' (duplicate, ignoring)", path);
1692       }
1693     }
1694   }
1695
1696   /* not that the order really matters, but it makes debugging easier */
1697   scan_paths = g_list_reverse (scan_paths);
1698
1699   while (scan_paths != NULL) {
1700     const gchar *path = scan_paths->data;
1701
1702     scan_hash += gst_plugin_ext_dep_scan_path_with_filenames (plugin, path,
1703         (const gchar **) dep->names, dep->flags);
1704     scan_hash = scan_hash << 1;
1705
1706     g_free (scan_paths->data);
1707     scan_paths = g_list_delete_link (scan_paths, scan_paths);
1708   }
1709
1710   GST_LOG_OBJECT (plugin, "done, scan_hash: %08x", scan_hash);
1711   return scan_hash;
1712 }
1713
1714 gboolean
1715 _priv_plugin_deps_files_changed (GstPlugin * plugin)
1716 {
1717   GList *l;
1718
1719   for (l = plugin->priv->deps; l != NULL; l = l->next) {
1720     GstPluginDep *dep = l->data;
1721
1722     if (dep->stat_hash != gst_plugin_ext_dep_get_stat_hash (plugin, dep))
1723       return TRUE;
1724   }
1725
1726   return FALSE;
1727 }
1728
1729 static void
1730 gst_plugin_ext_dep_free (GstPluginDep * dep)
1731 {
1732   g_strfreev (dep->env_vars);
1733   g_strfreev (dep->paths);
1734   g_strfreev (dep->names);
1735   g_slice_free (GstPluginDep, dep);
1736 }
1737
1738 static gboolean
1739 gst_plugin_ext_dep_strv_equal (gchar ** arr1, gchar ** arr2)
1740 {
1741   if (arr1 == arr2)
1742     return TRUE;
1743   if (arr1 == NULL || arr2 == NULL)
1744     return FALSE;
1745   for (; *arr1 != NULL && *arr2 != NULL; ++arr1, ++arr2) {
1746     if (strcmp (*arr1, *arr2) != 0)
1747       return FALSE;
1748   }
1749   return (*arr1 == *arr2);
1750 }
1751
1752 static gboolean
1753 gst_plugin_ext_dep_equals (GstPluginDep * dep, const gchar ** env_vars,
1754     const gchar ** paths, const gchar ** names, GstPluginDependencyFlags flags)
1755 {
1756   if (dep->flags != flags)
1757     return FALSE;
1758
1759   return gst_plugin_ext_dep_strv_equal (dep->env_vars, (gchar **) env_vars) &&
1760       gst_plugin_ext_dep_strv_equal (dep->paths, (gchar **) paths) &&
1761       gst_plugin_ext_dep_strv_equal (dep->names, (gchar **) names);
1762 }
1763
1764 /**
1765  * gst_plugin_add_dependency:
1766  * @plugin: a #GstPlugin
1767  * @env_vars: NULL-terminated array of environent variables affecting the
1768  *     feature set of the plugin (e.g. an environment variable containing
1769  *     paths where to look for additional modules/plugins of a library),
1770  *     or NULL. Environment variable names may be followed by a path component
1771  *      which will be added to the content of the environment variable, e.g.
1772  *      "HOME/.mystuff/plugins".
1773  * @paths: NULL-terminated array of directories/paths where dependent files
1774  *     may be.
1775  * @names: NULL-terminated array of file names (or file name suffixes,
1776  *     depending on @flags) to be used in combination with the paths from
1777  *     @paths and/or the paths extracted from the environment variables in
1778  *     @env_vars, or NULL.
1779  * @flags: optional flags, or #GST_PLUGIN_DEPENDENCY_FLAG_NONE
1780  *
1781  * Make GStreamer aware of external dependencies which affect the feature
1782  * set of this plugin (ie. the elements or typefinders associated with it).
1783  *
1784  * GStreamer will re-inspect plugins with external dependencies whenever any
1785  * of the external dependencies change. This is useful for plugins which wrap
1786  * other plugin systems, e.g. a plugin which wraps a plugin-based visualisation
1787  * library and makes visualisations available as GStreamer elements, or a
1788  * codec loader which exposes elements and/or caps dependent on what external
1789  * codec libraries are currently installed.
1790  *
1791  * Since: 0.10.22
1792  */
1793 void
1794 gst_plugin_add_dependency (GstPlugin * plugin, const gchar ** env_vars,
1795     const gchar ** paths, const gchar ** names, GstPluginDependencyFlags flags)
1796 {
1797   GstPluginDep *dep;
1798   GList *l;
1799
1800   g_return_if_fail (GST_IS_PLUGIN (plugin));
1801
1802   if ((env_vars == NULL || env_vars[0] == NULL) &&
1803       (paths == NULL || paths[0] == NULL)) {
1804     GST_DEBUG_OBJECT (plugin,
1805         "plugin registered empty dependency set. Ignoring");
1806     return;
1807   }
1808
1809   for (l = plugin->priv->deps; l != NULL; l = l->next) {
1810     if (gst_plugin_ext_dep_equals (l->data, env_vars, paths, names, flags)) {
1811       GST_LOG_OBJECT (plugin, "dependency already registered");
1812       return;
1813     }
1814   }
1815
1816   dep = g_slice_new (GstPluginDep);
1817
1818   dep->env_vars = g_strdupv ((gchar **) env_vars);
1819   dep->paths = g_strdupv ((gchar **) paths);
1820   dep->names = g_strdupv ((gchar **) names);
1821   dep->flags = flags;
1822
1823   dep->env_hash = gst_plugin_ext_dep_get_env_vars_hash (plugin, dep);
1824   dep->stat_hash = gst_plugin_ext_dep_get_stat_hash (plugin, dep);
1825
1826   plugin->priv->deps = g_list_append (plugin->priv->deps, dep);
1827
1828   GST_DEBUG_OBJECT (plugin, "added dependency:");
1829   for (; env_vars != NULL && *env_vars != NULL; ++env_vars)
1830     GST_DEBUG_OBJECT (plugin, " evar: %s", *env_vars);
1831   for (; paths != NULL && *paths != NULL; ++paths)
1832     GST_DEBUG_OBJECT (plugin, " path: %s", *paths);
1833   for (; names != NULL && *names != NULL; ++names)
1834     GST_DEBUG_OBJECT (plugin, " name: %s", *names);
1835 }
1836
1837 /**
1838  * gst_plugin_add_dependency_simple:
1839  * @plugin: the #GstPlugin
1840  * @env_vars: one or more environent variables (separated by ':', ';' or ','),
1841  *      or NULL. Environment variable names may be followed by a path component
1842  *      which will be added to the content of the environment variable, e.g.
1843  *      "HOME/.mystuff/plugins:MYSTUFF_PLUGINS_PATH"
1844  * @paths: one ore more directory paths (separated by ':' or ';' or ','),
1845  *      or NULL. Example: "/usr/lib/mystuff/plugins"
1846  * @names: one or more file names or file name suffixes (separated by commas),
1847  *   or NULL
1848  * @flags: optional flags, or #GST_PLUGIN_DEPENDENCY_FLAG_NONE
1849  *
1850  * Make GStreamer aware of external dependencies which affect the feature
1851  * set of this plugin (ie. the elements or typefinders associated with it).
1852  *
1853  * GStreamer will re-inspect plugins with external dependencies whenever any
1854  * of the external dependencies change. This is useful for plugins which wrap
1855  * other plugin systems, e.g. a plugin which wraps a plugin-based visualisation
1856  * library and makes visualisations available as GStreamer elements, or a
1857  * codec loader which exposes elements and/or caps dependent on what external
1858  * codec libraries are currently installed.
1859  *
1860  * Convenience wrapper function for gst_plugin_add_dependency() which
1861  * takes simple strings as arguments instead of string arrays, with multiple
1862  * arguments separated by predefined delimiters (see above).
1863  *
1864  * Since: 0.10.22
1865  */
1866 void
1867 gst_plugin_add_dependency_simple (GstPlugin * plugin,
1868     const gchar * env_vars, const gchar * paths, const gchar * names,
1869     GstPluginDependencyFlags flags)
1870 {
1871   gchar **a_evars = NULL;
1872   gchar **a_paths = NULL;
1873   gchar **a_names = NULL;
1874
1875   if (env_vars)
1876     a_evars = g_strsplit_set (env_vars, ":;,", -1);
1877   if (paths)
1878     a_paths = g_strsplit_set (paths, ":;,", -1);
1879   if (names)
1880     a_names = g_strsplit_set (names, ",", -1);
1881
1882   gst_plugin_add_dependency (plugin, (const gchar **) a_evars,
1883       (const gchar **) a_paths, (const gchar **) a_names, flags);
1884
1885   if (a_evars)
1886     g_strfreev (a_evars);
1887   if (a_paths)
1888     g_strfreev (a_paths);
1889   if (a_names)
1890     g_strfreev (a_names);
1891 }