/* 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., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/**

 * SECTION: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>.

 *

 * can add any object that subclasses #GstPluginFeature.

 *

 * Usually plugins are always automaticlly 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 <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 "gst_private.h"

#include "glib-compat-private.h"

#include <gst/gst.h>

#ifdef __SYMBIAN32__

#include <glib_global.h>

#endif

#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 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

 * Contact gstreamer-devel@lists.sourceforge.net if your license should 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: http://www.opensource.org/licenses/bsd-license.php

 */

static const gchar *valid_licenses[] = {

  "LGPL",                       /* GNU Lesser General Public License */

  "GPL",                        /* GNU General Public License */

  "QPL",                        /* Trolltech Qt Public License */

  "GPL/QPL",                    /* Combi-license of GPL + QPL */

  "MPL",                        /* MPL 1.1 license */

  "BSD",                        /* 3-clause BSD license */

  "MIT/X11",                    /* MIT/X11 license */

  "Proprietary",                /* Proprietary license */

  GST_LICENSE_UNKNOWN,          /* some other license */

  NULL

};

static GstPlugin *gst_plugin_register_func (GstPlugin * plugin,

static void gst_plugin_desc_copy (GstPluginDesc * dest,

    const GstPluginDesc * src);

static void gst_plugin_desc_free (GstPluginDesc * desc);

G_DEFINE_TYPE (GstPlugin, gst_plugin, GST_TYPE_OBJECT);

static void

gst_plugin_init (GstPlugin * plugin)

{

}

static void

gst_plugin_finalize (GObject * object)

{

  GstPlugin *plugin = GST_PLUGIN_CAST (object);

  GstRegistry *registry = gst_registry_get_default ();

  GList *g;

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

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

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

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

    }

  }

  g_free (plugin->filename);

  g_free (plugin->basename);

  gst_plugin_desc_free (&plugin->desc);

  G_OBJECT_CLASS (gst_plugin_parent_class)->finalize (object);

}

static void

gst_plugin_class_init (GstPluginClass * klass)

{

  G_OBJECT_CLASS (klass)->finalize = GST_DEBUG_FUNCPTR (gst_plugin_finalize);

}

#ifdef __SYMBIAN32__

EXPORT_C

#endif

GQuark

gst_plugin_error_quark (void)

{

  static GQuark quark = 0;

  if (!quark)

    quark = g_quark_from_static_string ("gst_plugin_error");

  return quark;

}

#ifndef GST_REMOVE_DEPRECATED

/* this function can be called in the GCC constructor extension, before

 * the _gst_plugin_initialize() was called. In that case, we store the

 * plugin description in a list to initialize it when we open the main

 * module later on.

 * When the main module is known, we can register the plugin right away.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

_gst_plugin_register_static (GstPluginDesc * desc)

{

  g_return_if_fail (desc != NULL);

  if (!_gst_plugin_inited) {

    /* We can't use any GLib functions here, since g_thread_init hasn't been

     * called yet, and we can't call it here either, or programs that don't

     * guard their g_thread_init calls in main() will just abort */

    ++_num_static_plugins;

    _static_plugins =

        realloc (_static_plugins, _num_static_plugins * sizeof (GstPluginDesc));

    /* assume strings in the GstPluginDesc are static const or live forever */

    _static_plugins[_num_static_plugins - 1] = *desc;

  } else {

    gst_plugin_register_static (desc->major_version, desc->minor_version,

        desc->name, desc->description, desc->plugin_init, desc->version,

        desc->license, desc->source, desc->package, desc->origin);

  }

}

#endif

/**

 * 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: 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.

 *

 * Since: 0.10.16

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

gboolean

gst_plugin_register_static (gint major_version, gint minor_version,

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

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

    const gchar * package, const gchar * origin)

{

#ifdef __SYMBIAN32__

  GstPluginDesc desc;

  GstPlugin *plugin;

  gboolean res = FALSE;

  desc.major_version = major_version;

  desc.minor_version = minor_version;

  desc.name = name;

  desc.description = description;

  desc.plugin_init = init_func;

  desc.version = version;

  desc.license = license;

  desc.source = source;

  desc.package = package;

  desc.origin = origin;

#else

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

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

  };

  GstPlugin *plugin;

  gboolean res = FALSE;

#endif

  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);

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

    res = gst_default_registry_add_plugin (plugin);

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

  }

  return res;

}

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

_gst_plugin_initialize (void)

{

  guint i;

  _gst_plugin_inited = TRUE;

  /* 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;

  }

}

/* 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)

{

  const gchar **check_license = valid_licenses;

  g_assert (check_license);

  while (*check_license) {

    if (strcmp (license, *check_license) == 0)

      return TRUE;

    check_license++;

  }

  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 *

{

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

    if (GST_CAT_DEFAULT)

      GST_WARNING ("plugin \"%s\" has incompatible version, not loading",

          plugin->filename);

    return NULL;

  }

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

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

    if (GST_CAT_DEFAULT)

      GST_WARNING ("plugin \"%s\" has incorrect GstPluginDesc, not loading",

          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",

          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);

  }

  if (GST_CAT_DEFAULT)

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

  return plugin;

}

#ifdef HAVE_SIGACTION

static struct sigaction oldaction;

/*

 * _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 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);

}

static void

_gst_plugin_fault_handler_restore (void)

{

}

static void

_gst_plugin_fault_handler_setup (void)

{

}

static void _gst_plugin_fault_handler_setup ();

static GStaticMutex gst_plugin_loading_mutex = G_STATIC_MUTEX_INIT;

/**

 * gst_plugin_load_file:

 * @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: a reference to the existing loaded GstPlugin, a reference to the

 * newly-loaded GstPlugin, or NULL if an error occurred.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

GstPlugin *

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

{

  GstPlugin *plugin;

  GModule *module;

  gboolean ret;

  gpointer ptr;

  struct stat file_status;

  GstRegistry *registry;

   #ifdef __SYMBIAN32__

   GstPluginDesc* (*fn)(void)=NULL;

   void *temp;

   #endif

  g_return_val_if_fail (filename != NULL, NULL);

  registry = gst_registry_get_default ();

  g_static_mutex_lock (&gst_plugin_loading_mutex);

  plugin = gst_registry_lookup (registry, filename);

  if (plugin) {

    if (plugin->module) {

      g_static_mutex_unlock (&gst_plugin_loading_mutex);

      return plugin;

    } else {

    }

  }

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

      filename);

  if (g_module_supported () == FALSE) {

    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;

  }