#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
+
+#include "gst_private.h"
+
#include <glib/gstdio.h>
#include <sys/types.h>
#ifdef HAVE_DIRENT_H
#endif
#include <signal.h>
#include <errno.h>
+#include <string.h>
-#include "gst_private.h"
#include "glib-compat-private.h"
#include <gst/gst.h>
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;
-#ifndef HAVE_WIN32
-static gboolean _gst_plugin_fault_handler_is_setup = FALSE;
-#endif
-
/* 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
};
static GstPlugin *gst_plugin_register_func (GstPlugin * plugin,
- const GstPluginDesc * desc);
+ const GstPluginDesc * desc, gpointer user_data);
static void gst_plugin_desc_copy (GstPluginDesc * dest,
const GstPluginDesc * src);
-static void gst_plugin_desc_free (GstPluginDesc * desc);
static void gst_plugin_ext_dep_free (GstPluginDep * dep);
GstRegistry *registry = gst_registry_get_default ();
GList *g;
- GST_DEBUG ("finalizing plugin %p", plugin);
+ GST_DEBUG ("finalizing plugin %" GST_PTR_FORMAT, 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_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_DEBUG_FUNCPTR (gst_plugin_finalize);
+ G_OBJECT_CLASS (klass)->finalize = gst_plugin_finalize;
g_type_class_add_private (klass, sizeof (GstPluginPrivate));
}
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.
- */
-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
*/
gboolean
gst_plugin_register_static (gint major_version, gint minor_version,
- const gchar * name, gchar * description, GstPluginInitFunc init_func,
+ 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,
+ init_func, version, license, source, package, origin, NULL,
};
GstPlugin *plugin;
gboolean res = FALSE;
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) {
+ plugin = g_object_newv (GST_TYPE_PLUGIN, 0, NULL);
+ if (gst_plugin_register_func (plugin, &desc, NULL) != 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;
+}
+
+/**
+ * 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: 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.
+ *
+ * Since: 0.10.24
+ *
+ */
+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_newv (GST_TYPE_PLUGIN, 0, NULL);
+ if (gst_plugin_register_func (plugin, &desc, user_data) != 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);
void
_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) {
}
}
+/* 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 (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 (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 = (hash << 1) ^ 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 GstPlugin *
-gst_plugin_register_func (GstPlugin * plugin, const GstPluginDesc * desc)
+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_plugin_desc_copy (&plugin->desc, desc);
- if (!((desc->plugin_init) (plugin))) {
- if (GST_CAT_DEFAULT)
- GST_WARNING ("plugin \"%s\" failed to initialise", plugin->filename);
- plugin->module = NULL;
- return NULL;
+ /* 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", plugin->filename);
+ return NULL;
+ }
+ } else {
+ if (!((desc->plugin_init) (plugin))) {
+ if (GST_CAT_DEFAULT)
+ GST_WARNING ("plugin \"%s\" failed to initialise", plugin->filename);
+ return NULL;
+ }
}
if (GST_CAT_DEFAULT)
#ifdef HAVE_SIGACTION
static struct sigaction oldaction;
+static gboolean _gst_plugin_fault_handler_is_setup = FALSE;
/*
* _gst_plugin_fault_handler_restore:
sigaction (SIGSEGV, &action, &oldaction);
}
-#else
+#else /* !HAVE_SIGACTION */
static void
_gst_plugin_fault_handler_restore (void)
{
_gst_plugin_fault_handler_setup (void)
{
}
-#endif
+#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;
+ }
-static void _gst_plugin_fault_handler_setup ();
+ return (*date_time == '\0');
+}
static GStaticMutex gst_plugin_loading_mutex = G_STATIC_MUTEX_INIT;
GstPlugin *
gst_plugin_load_file (const gchar * filename, GError ** error)
{
+ GstPluginDesc *desc;
GstPlugin *plugin;
GModule *module;
gboolean ret;
gpointer ptr;
- struct stat file_status;
+ GStatBuf file_status;
GstRegistry *registry;
+ gboolean new_plugin = TRUE;
+ GModuleFlags flags;
g_return_val_if_fail (filename != NULL, NULL);
plugin = gst_registry_lookup (registry, filename);
if (plugin) {
if (plugin->module) {
+ /* already loaded */
g_static_mutex_unlock (&gst_plugin_loading_mutex);
return plugin;
} else {
- gst_object_unref (plugin);
- plugin = NULL;
+ /* load plugin and update fields */
+ new_plugin = FALSE;
}
}
goto return_error;
}
- module = g_module_open (filename, G_MODULE_BIND_LOCAL);
+ 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 ());
goto return_error;
}
- plugin = g_object_new (GST_TYPE_PLUGIN, NULL);
-
- plugin->module = module;
- plugin->filename = g_strdup (filename);
- plugin->basename = g_path_get_basename (filename);
- plugin->file_mtime = file_status.st_mtime;
- plugin->file_size = file_status.st_size;
-
ret = g_module_symbol (module, "gst_plugin_desc", &ptr);
if (!ret) {
GST_DEBUG ("Could not find plugin entry point in \"%s\"", filename);
g_module_close (module);
goto return_error;
}
- plugin->orig_desc = (GstPluginDesc *) ptr;
-
- /* check plugin description: complain about bad values but accept them, to
- * maintain backwards compatibility (FIXME: 0.11) */
- CHECK_PLUGIN_DESC_FIELD (plugin->orig_desc, name, filename);
- CHECK_PLUGIN_DESC_FIELD (plugin->orig_desc, description, filename);
- CHECK_PLUGIN_DESC_FIELD (plugin->orig_desc, version, filename);
- CHECK_PLUGIN_DESC_FIELD (plugin->orig_desc, license, filename);
- CHECK_PLUGIN_DESC_FIELD (plugin->orig_desc, source, filename);
- CHECK_PLUGIN_DESC_FIELD (plugin->orig_desc, package, filename);
- CHECK_PLUGIN_DESC_FIELD (plugin->orig_desc, origin, filename);
+
+ desc = (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_newv (GST_TYPE_PLUGIN, 0, 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;
+ plugin->orig_desc = desc;
+
+ if (new_plugin) {
+ /* check plugin description: complain about bad values but accept them, to
+ * maintain backwards compatibility (FIXME: 0.11) */
+ CHECK_PLUGIN_DESC_FIELD (plugin->orig_desc, name, filename);
+ CHECK_PLUGIN_DESC_FIELD (plugin->orig_desc, description, filename);
+ CHECK_PLUGIN_DESC_FIELD (plugin->orig_desc, version, filename);
+ CHECK_PLUGIN_DESC_FIELD (plugin->orig_desc, license, filename);
+ CHECK_PLUGIN_DESC_FIELD (plugin->orig_desc, source, filename);
+ CHECK_PLUGIN_DESC_FIELD (plugin->orig_desc, package, filename);
+ CHECK_PLUGIN_DESC_FIELD (plugin->orig_desc, origin, filename);
+
+ if (plugin->orig_desc->release_datetime != NULL &&
+ !check_release_datetime (plugin->orig_desc->release_datetime)) {
+ GST_ERROR ("GstPluginDesc for '%s' has invalid datetime '%s'",
+ filename, plugin->orig_desc->release_datetime);
+ plugin->orig_desc->release_datetime = NULL;
+ }
+ }
GST_LOG ("Plugin %p for file \"%s\" prepared, calling entry function...",
plugin, filename);
GST_LOG ("Plugin %p for file \"%s\" prepared, registering...",
plugin, filename);
- if (!gst_plugin_register_func (plugin, plugin->orig_desc)) {
+ if (!gst_plugin_register_func (plugin, plugin->orig_desc, NULL)) {
/* remove signal handler */
_gst_plugin_fault_handler_restore ();
GST_DEBUG ("gst_plugin_register_func failed for plugin \"%s\"", filename);
GST_PLUGIN_ERROR_MODULE,
"File \"%s\" appears to be a GStreamer plugin, but it failed to initialize",
filename);
- g_module_close (module);
goto return_error;
}
_gst_plugin_fault_handler_filename = NULL;
GST_INFO ("plugin \"%s\" loaded", plugin->filename);
- gst_object_ref (plugin);
- gst_default_registry_add_plugin (plugin);
+ if (new_plugin) {
+ gst_object_ref (plugin);
+ gst_default_registry_add_plugin (plugin);
+ }
g_static_mutex_unlock (&gst_plugin_loading_mutex);
return plugin;
dest->major_version = src->major_version;
dest->minor_version = src->minor_version;
dest->name = g_intern_string (src->name);
- /* maybe intern the description too, just for convenience? */
- dest->description = g_strdup (src->description);
+ dest->description = g_intern_string (src->description);
dest->plugin_init = src->plugin_init;
dest->version = g_intern_string (src->version);
dest->license = g_intern_string (src->license);
dest->source = g_intern_string (src->source);
dest->package = g_intern_string (src->package);
dest->origin = g_intern_string (src->origin);
-}
-
-/* unused */
-static void
-gst_plugin_desc_free (GstPluginDesc * desc)
-{
- g_free (desc->description);
- memset (desc, 0, sizeof (GstPluginDesc));
+ dest->release_datetime = g_intern_string (src->release_datetime);
}
/**
return (plugin->module != NULL || plugin->filename == NULL);
}
+/**
+ * gst_plugin_get_cache_data:
+ * @plugin: a plugin
+ *
+ * Gets the plugin specific data cache. If it is %NULL there is no cached data
+ * stored. This is the case when the registry is getting rebuilt.
+ *
+ * Returns: The cached data as a #GstStructure or %NULL.
+ *
+ * Since: 0.10.24
+ */
+G_CONST_RETURN GstStructure *
+gst_plugin_get_cache_data (GstPlugin * plugin)
+{
+ g_return_val_if_fail (GST_IS_PLUGIN (plugin), NULL);
+
+ return plugin->priv->cache_data;
+}
+
+/**
+ * gst_plugin_set_cache_data:
+ * @plugin: a plugin
+ * @cache_data: a structure containing the data to cache
+ *
+ * Adds plugin specific data to cache. Passes the ownership of the structure to
+ * the @plugin.
+ *
+ * The cache is flushed every time the registry is rebuilt.
+ *
+ * Since: 0.10.24
+ */
+void
+gst_plugin_set_cache_data (GstPlugin * plugin, GstStructure * cache_data)
+{
+ g_return_if_fail (GST_IS_PLUGIN (plugin));
+ g_return_if_fail (GST_IS_STRUCTURE (cache_data));
+
+ if (plugin->priv->cache_data) {
+ gst_structure_free (plugin->priv->cache_data);
+ }
+ plugin->priv->cache_data = cache_data;
+}
+
#if 0
/**
* gst_plugin_feature_list:
}
static guint
-gst_plugin_ext_dep_get_hash_from_stat_entry (struct stat *s)
+gst_plugin_ext_dep_get_hash_from_stat_entry (GStatBuf * s)
{
if (!(s->st_mode & (S_IFDIR | S_IFREG)))
return (guint) - 1;
* the same order, and not in a random order */
while ((entry = g_dir_read_name (dir))) {
gboolean have_match;
- struct stat s;
+ GStatBuf s;
gchar *full_path;
guint fhash;
* and going through each entry to see if it matches one of our filenames. */
if (!recurse_into_dirs && !partial_names) {
for (i = 0; filenames[i] != NULL; ++i) {
- struct stat s;
+ GStatBuf s;
gchar *full_path;
guint fhash;
g_strfreev (dep->env_vars);
g_strfreev (dep->paths);
g_strfreev (dep->names);
- g_free (dep);
+ g_slice_free (GstPluginDep, dep);
}
static gboolean
GList *l;
g_return_if_fail (GST_IS_PLUGIN (plugin));
- g_return_if_fail (env_vars != NULL || paths != NULL);
+
+ if ((env_vars == NULL || env_vars[0] == NULL) &&
+ (paths == NULL || paths[0] == NULL)) {
+ GST_DEBUG_OBJECT (plugin,
+ "plugin registered empty dependency set. Ignoring");
+ return;
+ }
for (l = plugin->priv->deps; l != NULL; l = l->next) {
if (gst_plugin_ext_dep_equals (l->data, env_vars, paths, names, flags)) {
}
}
- dep = g_new0 (GstPluginDep, 1);
+ dep = g_slice_new (GstPluginDep);
dep->env_vars = g_strdupv ((gchar **) env_vars);
dep->paths = g_strdupv ((gchar **) paths);
projects / platform / upstream / gstreamer.git / blobdiff