/* GStreamer

 * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>

 *                    2000 Wim Taymans <wtay@chello.be>

 *

 * gstplugin.c: Plugin subsystem for loading elements, types, and libs

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

/**

 * SECTION:gstplugin

 * @title: GstPlugin

 * @short_description: Container for features loaded from a shared object module

 * @see_also: #GstPluginFeature, #GstElementFactory

 *

 * GStreamer is extensible, so #GstElement instances can be loaded at runtime.

 * A plugin system can provide one or more of the basic

 * <application>GStreamer</application> #GstPluginFeature subclasses.

 *

 * A plugin should export a symbol <symbol>gst_plugin_desc</symbol> that is a

 * struct of type #GstPluginDesc.

 * the plugin loader will check the version of the core library the plugin was

 * linked against and will create a new #GstPlugin. It will then call the

 * #GstPluginInitFunc function that was provided in the

 * <symbol>gst_plugin_desc</symbol>.

 *

 * Once you have a handle to a #GstPlugin (e.g. from the #GstRegistry), you

 * can add any object that subclasses #GstPluginFeature.

 *

 * Usually plugins are always automatically loaded so you don't need to call

 * gst_plugin_load() explicitly to bring it into memory. There are options to

 * statically link plugins to an app or even use GStreamer without a plugin

 * repository in which case gst_plugin_load() can be needed to bring the plugin

 * into memory.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "gst_private.h"

#include <glib/gstdio.h>

#include <sys/types.h>

#ifdef HAVE_DIRENT_H

#include <dirent.h>

#endif

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <signal.h>

#include <errno.h>

#include <string.h>

#include "glib-compat-private.h"

#include <gst/gst.h>

#define GST_CAT_DEFAULT GST_CAT_PLUGIN_LOADING

static guint _num_static_plugins;       /* 0    */

static GstPluginDesc *_static_plugins;  /* NULL */

static gboolean _gst_plugin_inited;

static gchar **_plugin_loading_whitelist;       /* NULL */

/* static variables for segfault handling of plugin loading */

static char *_gst_plugin_fault_handler_filename = NULL;

/* list of valid licenses.

 * One of these must be specified or the plugin won't be loaded

 * Please file a bug to request any additional license be added.

 *

 * GPL: http://www.gnu.org/copyleft/gpl.html

 * LGPL: http://www.gnu.org/copyleft/lesser.html

 * QPL: http://www.trolltech.com/licenses/qpl.html

 * MPL: http://www.opensource.org/licenses/mozilla1.1.php

 * MIT/X11: http://www.opensource.org/licenses/mit-license.php

 * 3-clause BSD: https://opensource.org/licenses/BSD-3-Clause

 * Zero-Clause BSD: https://opensource.org/licenses/0BSD

 */

static const gchar valid_licenses[] = "LGPL\000"        /* GNU Lesser General Public License */

    "GPL\000"                   /* GNU General Public License */

    "QPL\000"                   /* Trolltech Qt Public License */

    "GPL/QPL\000"               /* Combi-license of GPL + QPL */

    "MPL\000"                   /* MPL 1.1 license */

    "BSD\000"                   /* 3-clause BSD license */

    "MIT/X11\000"               /* MIT/X11 license */

    "0BSD\000"                  /* Zero-Clause BSD */

    "Proprietary\000"           /* Proprietary license */

    GST_LICENSE_UNKNOWN;        /* some other license */

static const guint8 valid_licenses_idx[] = { 0, 5, 9, 13, 21, 25, 29, 37, 42,

  54

};

static GstPlugin *gst_plugin_register_func (GstPlugin * plugin,

    const GstPluginDesc * desc, gpointer user_data);

static void gst_plugin_desc_copy (GstPluginDesc * dest,

    const GstPluginDesc * src);

static void gst_plugin_ext_dep_free (GstPluginDep * dep);

G_DEFINE_TYPE_WITH_PRIVATE (GstPlugin, gst_plugin, GST_TYPE_OBJECT);

static void

gst_plugin_init (GstPlugin * plugin)

{

  plugin->priv = gst_plugin_get_instance_private (plugin);

}

static void

gst_plugin_finalize (GObject * object)

{

  GstPlugin *plugin = GST_PLUGIN_CAST (object);

  GST_DEBUG ("finalizing plugin %" GST_PTR_FORMAT, plugin);

  /* FIXME: make registry add a weak ref instead */

#if 0

  GstRegistry *registry = gst_registry_get ();

  GList *g;

  for (g = registry->plugins; g; g = g->next) {

    if (g->data == (gpointer) plugin) {

      g_warning ("removing plugin that is still in registry");

    }

  }

#endif

  g_free (plugin->filename);

  g_free (plugin->basename);

  g_list_foreach (plugin->priv->deps, (GFunc) gst_plugin_ext_dep_free, NULL);

  g_list_free (plugin->priv->deps);

  plugin->priv->deps = NULL;

  if (plugin->priv->cache_data) {

    gst_structure_free (plugin->priv->cache_data);

  }

  G_OBJECT_CLASS (gst_plugin_parent_class)->finalize (object);

}

static void

gst_plugin_class_init (GstPluginClass * klass)

{

  G_OBJECT_CLASS (klass)->finalize = gst_plugin_finalize;

}

GQuark

gst_plugin_error_quark (void)

{

  static GQuark quark = 0;

  if (!quark)

    quark = g_quark_from_static_string ("gst_plugin_error");

  return quark;

}

/**

 * gst_plugin_register_static:

 * @major_version: the major version number of the GStreamer core that the

 *     plugin was compiled for, you can just use GST_VERSION_MAJOR here

 * @minor_version: the minor version number of the GStreamer core that the

 *     plugin was compiled for, you can just use GST_VERSION_MINOR here

 * @name: a unique name of the plugin (ideally prefixed with an application- or

 *     library-specific namespace prefix in order to avoid name conflicts in

 *     case a similar plugin with the same name ever gets added to GStreamer)

 * @description: description of the plugin

 * @init_func: (scope call): pointer to the init function of this plugin.

 * @version: version string of the plugin

 * @license: effective license of plugin. Must be one of the approved licenses

 *     (see #GstPluginDesc above) or the plugin will not be registered.

 * @source: source module plugin belongs to

 * @package: shipped package plugin belongs to

 * @origin: URL to provider of plugin

 *

 * Registers a static plugin, ie. a plugin which is private to an application

 * or library and contained within the application or library (as opposed to

 * being shipped as a separate module file).

 *

 * You must make sure that GStreamer has been initialised (with gst_init() or

 * via gst_init_get_option_group()) before calling this function.

 *

 * Returns: %TRUE if the plugin was registered correctly, otherwise %FALSE.

 */

gboolean

gst_plugin_register_static (gint major_version, gint minor_version,

    const gchar * name, const gchar * description, GstPluginInitFunc init_func,

    const gchar * version, const gchar * license, const gchar * source,

    const gchar * package, const gchar * origin)

{

  GstPluginDesc desc = { major_version, minor_version, name, description,

    init_func, version, license, source, package, origin, NULL,

  };

  GstPlugin *plugin;

  gboolean res = FALSE;

  g_return_val_if_fail (name != NULL, FALSE);

  g_return_val_if_fail (description != NULL, FALSE);

  g_return_val_if_fail (init_func != NULL, FALSE);

  g_return_val_if_fail (version != NULL, FALSE);

  g_return_val_if_fail (license != NULL, FALSE);

  g_return_val_if_fail (source != NULL, FALSE);

  g_return_val_if_fail (package != NULL, FALSE);

  g_return_val_if_fail (origin != NULL, FALSE);

  /* make sure gst_init() has been called */

  g_return_val_if_fail (_gst_plugin_inited != FALSE, FALSE);

  GST_LOG ("attempting to load static plugin \"%s\" now...", name);

  plugin = g_object_new (GST_TYPE_PLUGIN, NULL);

  if (gst_plugin_register_func (plugin, &desc, NULL) != NULL) {

    GST_INFO ("registered static plugin \"%s\"", name);

    res = gst_registry_add_plugin (gst_registry_get (), plugin);

    GST_INFO ("added static plugin \"%s\", result: %d", name, res);

  }

  return res;

}

/**

 * gst_plugin_register_static_full:

 * @major_version: the major version number of the GStreamer core that the

 *     plugin was compiled for, you can just use GST_VERSION_MAJOR here

 * @minor_version: the minor version number of the GStreamer core that the

 *     plugin was compiled for, you can just use GST_VERSION_MINOR here

 * @name: a unique name of the plugin (ideally prefixed with an application- or

 *     library-specific namespace prefix in order to avoid name conflicts in

 *     case a similar plugin with the same name ever gets added to GStreamer)

 * @description: description of the plugin

 * @init_full_func: (scope call): pointer to the init function with user data

 *     of this plugin.

 * @version: version string of the plugin

 * @license: effective license of plugin. Must be one of the approved licenses

 *     (see #GstPluginDesc above) or the plugin will not be registered.

 * @source: source module plugin belongs to

 * @package: shipped package plugin belongs to

 * @origin: URL to provider of plugin

 * @user_data: gpointer to user data

 *

 * Registers a static plugin, ie. a plugin which is private to an application

 * or library and contained within the application or library (as opposed to

 * being shipped as a separate module file) with a #GstPluginInitFullFunc

 * which allows user data to be passed to the callback function (useful

 * for bindings).

 *

 * You must make sure that GStreamer has been initialised (with gst_init() or

 * via gst_init_get_option_group()) before calling this function.

 *

 * Returns: %TRUE if the plugin was registered correctly, otherwise %FALSE.

 */

gboolean

gst_plugin_register_static_full (gint major_version, gint minor_version,

    const gchar * name, const gchar * description,

    GstPluginInitFullFunc init_full_func, const gchar * version,

    const gchar * license, const gchar * source, const gchar * package,

    const gchar * origin, gpointer user_data)

{

  GstPluginDesc desc = { major_version, minor_version, name, description,

    (GstPluginInitFunc) init_full_func, version, license, source, package,

    origin, NULL,

  };

  GstPlugin *plugin;

  gboolean res = FALSE;

  g_return_val_if_fail (name != NULL, FALSE);

  g_return_val_if_fail (description != NULL, FALSE);

  g_return_val_if_fail (init_full_func != NULL, FALSE);

  g_return_val_if_fail (version != NULL, FALSE);

  g_return_val_if_fail (license != NULL, FALSE);

  g_return_val_if_fail (source != NULL, FALSE);

  g_return_val_if_fail (package != NULL, FALSE);

  g_return_val_if_fail (origin != NULL, FALSE);

  /* make sure gst_init() has been called */

  g_return_val_if_fail (_gst_plugin_inited != FALSE, FALSE);

  GST_LOG ("attempting to load static plugin \"%s\" now...", name);

  plugin = g_object_new (GST_TYPE_PLUGIN, NULL);

  if (gst_plugin_register_func (plugin, &desc, user_data) != NULL) {

    GST_INFO ("registered static plugin \"%s\"", name);

    res = gst_registry_add_plugin (gst_registry_get (), plugin);

    GST_INFO ("added static plugin \"%s\", result: %d", name, res);

  }

  return res;

}

void

_priv_gst_plugin_initialize (void)

{

  const gchar *whitelist;

  guint i;

  _gst_plugin_inited = TRUE;

  whitelist = g_getenv ("GST_PLUGIN_LOADING_WHITELIST");

  if (whitelist != NULL && *whitelist != '\0') {

    _plugin_loading_whitelist = g_strsplit (whitelist,

        G_SEARCHPATH_SEPARATOR_S, -1);

    for (i = 0; _plugin_loading_whitelist[i] != NULL; ++i) {

      GST_INFO ("plugins whitelist entry: %s", _plugin_loading_whitelist[i]);

    }

  }

  /* now register all static plugins */

  GST_INFO ("registering %u static plugins", _num_static_plugins);

  for (i = 0; i < _num_static_plugins; ++i) {

    gst_plugin_register_static (_static_plugins[i].major_version,

        _static_plugins[i].minor_version, _static_plugins[i].name,

        _static_plugins[i].description, _static_plugins[i].plugin_init,

        _static_plugins[i].version, _static_plugins[i].license,

        _static_plugins[i].source, _static_plugins[i].package,

        _static_plugins[i].origin);

  }

  if (_static_plugins) {

    free (_static_plugins);

    _static_plugins = NULL;

    _num_static_plugins = 0;

  }

}

/* Whitelist entry format:

 *

 *   plugin1,plugin2@pathprefix or

 *   plugin1,plugin2@* or just

 *   plugin1,plugin2 or

 *   source-package@pathprefix or

 *   source-package@* or just

 *   source-package

 *

 * ie. the bit before the path will be checked against both the plugin

 * name and the plugin's source package name, to keep the format simple.

 */

static gboolean

gst_plugin_desc_matches_whitelist_entry (const GstPluginDesc * desc,

    const gchar * filename, const gchar * pattern)

{

  const gchar *sep;

  gboolean ret = FALSE;

  gchar *name;

  GST_LOG ("Whitelist pattern '%s', plugin: %s of %s@%s", pattern, desc->name,

      desc->source, GST_STR_NULL (filename));

  /* do we have a path prefix? */

  sep = strchr (pattern, '@');

  if (sep != NULL && strcmp (sep, "@*") != 0 && strcmp (sep, "@") != 0) {

    /* paths are not canonicalised or treated with realpath() here. This

     * should be good enough for our use case, since we just use the paths

     * autotools uses, and those will be constructed from the same prefix. */

    if (filename != NULL && !g_str_has_prefix (filename, sep + 1))

      return FALSE;

    GST_LOG ("%s matches path prefix %s", GST_STR_NULL (filename), sep + 1);

  }

  if (sep != NULL) {

    name = g_strndup (pattern, (gsize) (sep - pattern));

  } else {

    name = g_strdup (pattern);

  }

  g_strstrip (name);

  if (!g_ascii_isalnum (*name)) {

    GST_WARNING ("Invalid whitelist pattern: %s", pattern);

    goto done;

  }

  /* now check plugin names / source package name */

  if (strchr (name, ',') == NULL) {

    /* only a single name: either a plugin name or the source package name */

    ret = (strcmp (desc->source, name) == 0 || strcmp (desc->name, name) == 0);

  } else {

    gchar **n, **names;

    /* multiple names: assume these are plugin names */

    names = g_strsplit (name, ",", -1);

    for (n = names; n != NULL && *n != NULL; ++n) {

      g_strstrip (*n);

      if (strcmp (desc->name, *n) == 0) {

        ret = TRUE;

        break;

      }

    }

    g_strfreev (names);

  }

  GST_LOG ("plugin / source package name match: %d", ret);

done:

  g_free (name);

  return ret;

}

gboolean

priv_gst_plugin_desc_is_whitelisted (const GstPluginDesc * desc,

    const gchar * filename)

{

  gchar **entry;

  if (_plugin_loading_whitelist == NULL)

    return TRUE;

  for (entry = _plugin_loading_whitelist; *entry != NULL; ++entry) {

    if (gst_plugin_desc_matches_whitelist_entry (desc, filename, *entry)) {

      GST_LOG ("Plugin %s is in whitelist", filename);

      return TRUE;

    }

  }

  GST_LOG ("Plugin %s (package %s, file %s) not in whitelist", desc->name,

      desc->source, filename);

  return FALSE;

}

gboolean

priv_gst_plugin_loading_have_whitelist (void)

{

  return (_plugin_loading_whitelist != NULL);

}

guint32

priv_gst_plugin_loading_get_whitelist_hash (void)

{

  guint32 hash = 0;

  if (_plugin_loading_whitelist != NULL) {

    gchar **w;

    for (w = _plugin_loading_whitelist; *w != NULL; ++w)

      hash ^= g_str_hash (*w);

  }

  return hash;

}

/* this function could be extended to check if the plugin license matches the

 * applications license (would require the app to register its license somehow).

 * We'll wait for someone who's interested in it to code it :)

 */

static gboolean

gst_plugin_check_license (const gchar * license)

{

  gint i;

  for (i = 0; i < G_N_ELEMENTS (valid_licenses_idx); ++i) {

    if (strcmp (license, valid_licenses + valid_licenses_idx[i]) == 0)

      return TRUE;

  }

  return FALSE;

}

static gboolean

gst_plugin_check_version (gint major, gint minor)

{

  /* return NULL if the major and minor version numbers are not compatible */

  /* with ours. */

  if (major != GST_VERSION_MAJOR || minor > GST_VERSION_MINOR)

    return FALSE;

  return TRUE;

}

static GstPlugin *

gst_plugin_register_func (GstPlugin * plugin, const GstPluginDesc * desc,

    gpointer user_data)

{

  if (!gst_plugin_check_version (desc->major_version, desc->minor_version)) {

    if (GST_CAT_DEFAULT)

      GST_WARNING ("plugin \"%s\" has incompatible version "

          "(plugin: %d.%d, gst: %d,%d), not loading",

          GST_STR_NULL (plugin->filename), desc->major_version,

          desc->minor_version, GST_VERSION_MAJOR, GST_VERSION_MINOR);

    return NULL;

  }

  if (!desc->license || !desc->description || !desc->source ||

      !desc->package || !desc->origin) {

    if (GST_CAT_DEFAULT)

      GST_WARNING ("plugin \"%s\" has missing detail in GstPluginDesc, not "

          "loading", GST_STR_NULL (plugin->filename));

    return NULL;

  }

  if (!gst_plugin_check_license (desc->license)) {

    if (GST_CAT_DEFAULT)

      GST_WARNING ("plugin \"%s\" has invalid license \"%s\", not loading",

          GST_STR_NULL (plugin->filename), desc->license);

    return NULL;

  }

  if (GST_CAT_DEFAULT)

    GST_LOG ("plugin \"%s\" looks good", GST_STR_NULL (plugin->filename));

  gst_plugin_desc_copy (&plugin->desc, desc);

  /* make resident so we're really sure it never gets unloaded again.

   * Theoretically this is not needed, but practically it doesn't hurt.

   * And we're rather safe than sorry. */

  if (plugin->module)

    g_module_make_resident (plugin->module);

  if (user_data) {

    if (!(((GstPluginInitFullFunc) (desc->plugin_init)) (plugin, user_data))) {

      if (GST_CAT_DEFAULT)

        GST_WARNING ("plugin \"%s\" failed to initialise",

            GST_STR_NULL (plugin->filename));

      return NULL;

    }

  } else {

    if (!((desc->plugin_init) (plugin))) {

      if (GST_CAT_DEFAULT)

        GST_WARNING ("plugin \"%s\" failed to initialise",

            GST_STR_NULL (plugin->filename));

      return NULL;

    }

  }

  if (GST_CAT_DEFAULT)

    GST_LOG ("plugin \"%s\" initialised", GST_STR_NULL (plugin->filename));

  return plugin;

}

#ifdef HAVE_SIGACTION

static struct sigaction oldaction;

static gboolean _gst_plugin_fault_handler_is_setup = FALSE;

/*

 * _gst_plugin_fault_handler_restore:

 * segfault handler restorer

 */

static void

_gst_plugin_fault_handler_restore (void)

{

  if (!_gst_plugin_fault_handler_is_setup)

    return;

  _gst_plugin_fault_handler_is_setup = FALSE;

  sigaction (SIGSEGV, &oldaction, NULL);

}

/*

 * _gst_plugin_fault_handler_sighandler:

 * segfault handler implementation

 */

static void

_gst_plugin_fault_handler_sighandler (int signum)

{

  /* We need to restore the fault handler or we'll keep getting it */

  _gst_plugin_fault_handler_restore ();

  switch (signum) {

    case SIGSEGV:

      g_print ("\nERROR: ");

      g_print ("Caught a segmentation fault while loading plugin file:\n");

      g_print ("%s\n\n", _gst_plugin_fault_handler_filename);

      g_print ("Please either:\n");

      g_print ("- remove it and restart.\n");

      g_print

          ("- run with --gst-disable-segtrap --gst-disable-registry-fork and debug.\n");

      exit (-1);

      break;

    default:

      g_print ("Caught unhandled signal on plugin loading\n");

      break;

  }

}

/*

 * _gst_plugin_fault_handler_setup:

 * sets up the segfault handler

 */

static void

_gst_plugin_fault_handler_setup (void)

{

  struct sigaction action;

  /* if asked to leave segfaults alone, just return */

  if (!gst_segtrap_is_enabled ())

    return;

  if (_gst_plugin_fault_handler_is_setup)

    return;

  _gst_plugin_fault_handler_is_setup = TRUE;

  memset (&action, 0, sizeof (action));

  action.sa_handler = _gst_plugin_fault_handler_sighandler;

  sigaction (SIGSEGV, &action, &oldaction);

}

#else /* !HAVE_SIGACTION */

static void

_gst_plugin_fault_handler_restore (void)

{

}

static void

_gst_plugin_fault_handler_setup (void)

{

}

#endif /* HAVE_SIGACTION */

/* g_time_val_from_iso8601() doesn't do quite what we want */

static gboolean

check_release_datetime (const gchar * date_time)

{

  guint64 val;

  /* we require YYYY-MM-DD or YYYY-MM-DDTHH:MMZ format */

  if (!g_ascii_isdigit (*date_time))

    return FALSE;

  val = g_ascii_strtoull (date_time, (gchar **) & date_time, 10);

  if (val < 2000 || val > 2100 || *date_time != '-')

    return FALSE;

  val = g_ascii_strtoull (date_time + 1, (gchar **) & date_time, 10);

  if (val == 0 || val > 12 || *date_time != '-')

    return FALSE;

  val = g_ascii_strtoull (date_time + 1, (gchar **) & date_time, 10);

  if (val == 0 || val > 32)

    return FALSE;

  /* end of string or date/time separator + HH:MMZ */

  if (*date_time == 'T' || *date_time == ' ') {

    val = g_ascii_strtoull (date_time + 1, (gchar **) & date_time, 10);

    if (val > 24 || *date_time != ':')

      return FALSE;

    val = g_ascii_strtoull (date_time + 1, (gchar **) & date_time, 10);

    if (val > 59 || *date_time != 'Z')

      return FALSE;

    ++date_time;

  }

  return (*date_time == '\0');

}

static GMutex gst_plugin_loading_mutex;

#define CHECK_PLUGIN_DESC_FIELD(desc,field,fn)                               \

  if (G_UNLIKELY ((desc)->field == NULL || *(desc)->field == '\0')) {        \

    g_warning ("Plugin description for '%s' has no valid %s field", fn, G_STRINGIFY (field)); \

    g_set_error (error, GST_PLUGIN_ERROR, GST_PLUGIN_ERROR_MODULE, \

        "Plugin %s has invalid plugin description field '%s'", \

        filename, G_STRINGIFY (field)); \

    goto return_error;                                                       \

  }

/**

 * gst_plugin_load_file:

 * @filename: (type filename): the plugin filename to load

 * @error: pointer to a %NULL-valued GError

 *

 * Loads the given plugin and refs it.  Caller needs to unref after use.

 *

 * Returns: (transfer full): a reference to the existing loaded GstPlugin, a

 * reference to the newly-loaded GstPlugin, or %NULL if an error occurred.

 */

GstPlugin *

gst_plugin_load_file (const gchar * filename, GError ** error)

{

  return _priv_gst_plugin_load_file_for_registry (filename, NULL, error);

}

static gchar *

extract_symname (const char *filename)

{

  gchar *bname, *name, *symname;

  const gchar *dot;

  gsize prefix_len, len;

  int i;

  bname = g_path_get_basename (filename);

  for (i = 0; bname[i]; ++i) {

    if (bname[i] == '-')

      bname[i] = '_';

  }

  if (g_str_has_prefix (bname, "libgst"))

    prefix_len = 6;

  else if (g_str_has_prefix (bname, "lib"))

    prefix_len = 3;

  else if (g_str_has_prefix (bname, "gst"))

    prefix_len = 3;

  else

    prefix_len = 0;             /* use whole name (minus suffix) as plugin name */

  dot = g_utf8_strchr (bname, -1, '.');

  if (dot)

    len = dot - bname - prefix_len;

  else

    len = strlen (bname + prefix_len);

  name = g_strndup (bname + prefix_len, len);

  g_free (bname);

  symname = g_strconcat ("gst_plugin_", name, "_get_desc", NULL);

  g_free (name);

  return symname;

}

/* Note: The return value is (transfer full) although we work with floating

 * references here. If a new plugin instance is created, it is always sinked

 * in the registry first and a new reference is returned

 */

GstPlugin *

_priv_gst_plugin_load_file_for_registry (const gchar * filename,

    GstRegistry * registry, GError ** error)

{

  const GstPluginDesc *desc;

  GstPlugin *plugin;

  gchar *symname;

  GModule *module;

  gboolean ret;

  gpointer ptr;

  GStatBuf file_status;

  gboolean new_plugin = TRUE;

  GModuleFlags flags;

  g_return_val_if_fail (filename != NULL, NULL);

  if (registry == NULL)

    registry = gst_registry_get ();

  g_mutex_lock (&gst_plugin_loading_mutex);

  plugin = gst_registry_lookup (registry, filename);

  if (plugin) {

    if (plugin->module) {

      /* already loaded */

      g_mutex_unlock (&gst_plugin_loading_mutex);

      return plugin;

    } else {

      /* load plugin and update fields */

      new_plugin = FALSE;

    }

  }

  GST_CAT_DEBUG (GST_CAT_PLUGIN_LOADING, "attempt to load plugin \"%s\"",

      filename);

  if (!g_module_supported ()) {

    GST_CAT_DEBUG (GST_CAT_PLUGIN_LOADING, "module loading not supported");

    g_set_error (error,

        GST_PLUGIN_ERROR,

        GST_PLUGIN_ERROR_MODULE, "Dynamic loading not supported");

    goto return_error;

  }

  if (g_stat (filename, &file_status)) {

    GST_CAT_DEBUG (GST_CAT_PLUGIN_LOADING, "problem accessing file");

    g_set_error (error,

        GST_PLUGIN_ERROR,

        GST_PLUGIN_ERROR_MODULE, "Problem accessing file %s: %s", filename,

        g_strerror (errno));

    goto return_error;

  }

  flags = G_MODULE_BIND_LOCAL;

  /* libgstpython.so is the gst-python plugin loader. It needs to be loaded with

   * G_MODULE_BIND_LAZY.

   *

   * Ideally there should be a generic way for plugins to specify that they

   * need to be loaded with _LAZY.

   * */

  if (strstr (filename, "libgstpython"))

    flags |= G_MODULE_BIND_LAZY;

  module = g_module_open (filename, flags);

  if (module == NULL) {

    GST_CAT_WARNING (GST_CAT_PLUGIN_LOADING, "module_open failed: %s",

        g_module_error ());

    g_set_error (error,

        GST_PLUGIN_ERROR, GST_PLUGIN_ERROR_MODULE, "Opening module failed: %s",

        g_module_error ());

    /* If we failed to open the shared object, then it's probably because a

     * plugin is linked against the wrong libraries. Print out an easy-to-see

     * message in this case. */

    g_warning ("Failed to load plugin '%s': %s", filename, g_module_error ());

    goto return_error;

  }

  symname = extract_symname (filename);

  ret = g_module_symbol (module, symname, &ptr);

  if (ret) {

    GstPluginDesc *(*get_desc) (void) = ptr;

    ptr = get_desc ();

  } else {

    GST_DEBUG ("Could not find symbol '%s', falling back to gst_plugin_desc",

        symname);

    ret = g_module_symbol (module, "gst_plugin_desc", &ptr);

  }

  g_free (symname);

  if (!ret) {

    GST_DEBUG ("Could not find plugin entry point in \"%s\"", filename);

    g_set_error (error,

        GST_PLUGIN_ERROR,

        GST_PLUGIN_ERROR_MODULE,

        "File \"%s\" is not a GStreamer plugin", filename);

    g_module_close (module);

    goto return_error;

  }

  desc = (const GstPluginDesc *) ptr;

  if (priv_gst_plugin_loading_have_whitelist () &&

      !priv_gst_plugin_desc_is_whitelisted (desc, filename)) {

    GST_INFO ("Whitelist specified and plugin not in whitelist, not loading: "

        "name=%s, package=%s, file=%s", desc->name, desc->source, filename);

    g_set_error (error, GST_PLUGIN_ERROR, GST_PLUGIN_ERROR_MODULE,

        "Not loading plugin file \"%s\", not in whitelist", filename);

    g_module_close (module);

    goto return_error;

  }

  if (new_plugin) {

    plugin = g_object_new (GST_TYPE_PLUGIN, NULL);

    plugin->file_mtime = file_status.st_mtime;

    plugin->file_size = file_status.st_size;

    plugin->filename = g_strdup (filename);

    plugin->basename = g_path_get_basename (filename);

  }

  plugin->module = module;

  if (new_plugin) {

    /* check plugin description: complain about bad values and fail */

    CHECK_PLUGIN_DESC_FIELD (desc, name, filename);

    CHECK_PLUGIN_DESC_FIELD (desc, description, filename);

    CHECK_PLUGIN_DESC_FIELD (desc, version, filename);

    CHECK_PLUGIN_DESC_FIELD (desc, license, filename);

    CHECK_PLUGIN_DESC_FIELD (desc, source, filename);

    CHECK_PLUGIN_DESC_FIELD (desc, package, filename);

    CHECK_PLUGIN_DESC_FIELD (desc, origin, filename);

    if (desc->name != NULL && desc->name[0] == '"') {

      g_warning ("Invalid plugin name '%s' - fix your GST_PLUGIN_DEFINE "

          "(remove quotes around plugin name)", desc->name);

    }

    if (desc->release_datetime != NULL &&

        !check_release_datetime (desc->release_datetime)) {

      g_warning ("GstPluginDesc for '%s' has invalid datetime '%s'",

          filename, desc->release_datetime);

      g_set_error (error, GST_PLUGIN_ERROR, GST_PLUGIN_ERROR_MODULE,

          "Plugin %s has invalid plugin description field 'release_datetime'",

          filename);

      goto return_error;

    }

  }

  GST_LOG ("Plugin %p for file \"%s\" prepared, calling entry function...",

      plugin, filename);

  /* this is where we load the actual .so, so let's trap SIGSEGV */

  _gst_plugin_fault_handler_setup ();