FCL/sf/mw/gstreamer: comparison gstreamer_core/gst/gstregistrybinary.c

equal deleted inserted replaced

-:4b0c6ed43234
+:8e837d1bf446
 /* GStreamer
 * Copyright (C) 2006 Josep Torra <josep@fluendo.com>
 *               2006 Mathieu Garcia <matthieu@fluendo.com>
 *               2006,2007 Stefan Kost <ensonic@users.sf.net>
+*               2008 Sebastian Dröge <slomo@circular-chaos.org>
 *
 * gstregistrybinary.c: GstRegistryBinary object, support routines
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */
 /* FIXME:
-* - Add random key to libgstreamer during build and only accept registry,
-*   if key matches (or is the version check enough)
 * - keep registry binary blob and reference strings
-*   - don't free/unmmap contents when leaving gst_registry_binary_read_cache()
+*   - don't free/
+#ifdef __SYMBIAN32__
+EXPORT_C
+#endif
+unmmap contents when leaving gst_registry_binary_read_cache()
 *     - free at gst_deinit() / _priv_gst_registry_cleanup() ?
 *   - GstPlugin:
 *     - GST_PLUGIN_FLAG_CONST
-*   -GstPluginFeature, GstIndexFactory, GstElementFactory
+*   - GstPluginFeature, GstIndexFactory, GstElementFactory
 *     - needs Flags (GST_PLUGIN_FEATURE_FLAG_CONST)
 *     - can we turn loaded into flag?
 * - why do we collect a list of binary chunks and not write immediately
 *   - because we need to process subchunks, before we can set e.g. nr_of_items
 *     in parent chunk
-* - need more robustness
-*   - don't parse beyond mem-block size
-*   - include md5-sum ?
 */
 #ifdef HAVE_CONFIG_H
 #  include "config.h"
 #endif
 #include "glib-compat-private.h"
 #define GST_CAT_DEFAULT GST_CAT_REGISTRY
-/* macros */
+/* count string length, but return -1 if we hit the eof */
+static gint
-#define unpack_element(_inptr, _outptr, _element)  \
+_strnlen (const gchar * str, gint maxlen)
-_outptr = (_element *)_inptr; \
+{
-_inptr += sizeof (_element)
+gint len = 0;
-#define unpack_const_string(_inptr, _outptr) \
+if (G_UNLIKELY (len == maxlen))
-_outptr = g_intern_string ((const gchar *)_inptr); \
+return -1;
-_inptr += strlen(_outptr) + 1
+while (*str++ != '\0') {
-#define unpack_string(_inptr, _outptr)  \
+len++;
-_outptr = g_strdup ((gchar *)_inptr); \
+if (G_UNLIKELY (len == maxlen))
-_inptr += strlen(_outptr) + 1
+return -1;
+}
-#if !GST_HAVE_UNALIGNED_ACCESS
+return len;
-#  define alignment32(_address)  (gsize)_address%4
+}
-#  define align32(_ptr)          _ptr += (( alignment32(_ptr) == 0) ? 0 : 4-alignment32(_ptr))
+/* reading macros */
+#define unpack_element(inptr, outptr, element, endptr, error_label) G_STMT_START{ \
+if (inptr + sizeof(element) >= endptr) \
+goto error_label; \
+outptr = (element *) inptr; \
+inptr += sizeof (element); \
+}G_STMT_END
+#define unpack_const_string(inptr, outptr, endptr, error_label) G_STMT_START{\
+gint _len = _strnlen (inptr, (endptr-inptr)); \
+if (_len == -1) \
+goto error_label; \
+outptr = g_intern_string ((const gchar *)inptr); \
+inptr += _len + 1; \
+}G_STMT_END
+#define unpack_string(inptr, outptr, endptr, error_label)  G_STMT_START{\
+gint _len = _strnlen (inptr, (endptr-inptr)); \
+if (_len == -1) \
+goto error_label; \
+outptr = g_memdup ((gconstpointer)inptr, _len + 1); \
+inptr += _len + 1; \
+}G_STMT_END
+#define ALIGNMENT            (sizeof (void *))
+#define alignment(_address)  (gsize)_address%ALIGNMENT
+#define align(_ptr)          _ptr += (( alignment(_ptr) == 0) ? 0 : ALIGNMENT-alignment(_ptr))
+/* Registry saving */
+#ifdef G_OS_WIN32
+/* On win32, we can't use g_mkstmp(), because of cross-DLL file I/O problems.
+* So, we just create the entire binary registry in memory, then write it out
+* with g_file_set_contents(), which creates a temporary file internally
+*/
+typedef struct BinaryRegistryCache
+{
+const char *location;
+guint8 *mem;
+gssize len;
+} BinaryRegistryCache;
+static BinaryRegistryCache *
+gst_registry_binary_cache_init (GstRegistry * registry, const char *location)
+{
+BinaryRegistryCache *cache = g_new0 (BinaryRegistryCache, 1);
+cache->location = location;
+return cache;
+}
+static int
+gst_registry_binary_cache_write (GstRegistry * registry,
+BinaryRegistryCache * cache, unsigned long offset,
+const void *data, int length)
+{
+cache->len = MAX (offset + length, cache->len);
+cache->mem = g_realloc (cache->mem, cache->len);
+memcpy (cache->mem + offset, data, length);
+return length;
+}
+static gboolean
+gst_registry_binary_cache_finish (GstRegistry * registry,
+BinaryRegistryCache * cache, gboolean success)
+{
+gboolean ret = TRUE;
+GError *error = NULL;
+if (!g_file_set_contents (cache->location, (const gchar *) cache->mem,
+cache->len, &error)) {
+/* Probably the directory didn't exist; create it */
+gchar *dir;
+dir = g_path_get_dirname (cache->location);
+g_mkdir_with_parents (dir, 0777);
+g_free (dir);
+g_error_free (error);
+error = NULL;
+if (!g_file_set_contents (cache->location, (const gchar *) cache->mem,
+cache->len, &error)) {
+GST_ERROR ("Failed to write to cache file: %s", error->message);
+g_error_free (error);
+ret = FALSE;
+}
+}
+g_free (cache->mem);
+g_free (cache);
+return ret;
+}
 #else
-#  define alignment32(_address)  0
+typedef struct BinaryRegistryCache
-#  define align32(_ptr)          do {} while(0)
+{
+const char *location;
+char *tmp_location;
+unsigned long currentoffset;
+} BinaryRegistryCache;
+static BinaryRegistryCache *
+gst_registry_binary_cache_init (GstRegistry * registry, const char *location)
+{
+BinaryRegistryCache *cache = g_new0 (BinaryRegistryCache, 1);
+cache->location = location;
+cache->tmp_location = g_strconcat (location, ".tmpXXXXXX", NULL);
+registry->cache_file = g_mkstemp (cache->tmp_location);
+if (registry->cache_file == -1) {
+gchar *dir;
+/* oops, I bet the directory doesn't exist */
+dir = g_path_get_dirname (location);
+g_mkdir_with_parents (dir, 0777);
+g_free (dir);
+/* the previous g_mkstemp call overwrote the XXXXXX placeholder ... */
+g_free (cache->tmp_location);
+cache->tmp_location = g_strconcat (location, ".tmpXXXXXX", NULL);
+registry->cache_file = g_mkstemp (cache->tmp_location);
+if (registry->cache_file == -1) {
+GST_DEBUG ("g_mkstemp() failed: %s", g_strerror (errno));
+g_free (cache->tmp_location);
+g_free (cache);
+return NULL;
+}
+}
+return cache;
+}
+static int
+gst_registry_binary_cache_write (GstRegistry * registry,
+BinaryRegistryCache * cache, unsigned long offset,
+const void *data, int length)
+{
+long written;
+if (offset != cache->currentoffset) {
+if (lseek (registry->cache_file, offset, SEEK_SET) != 0) {
+GST_ERROR ("Seeking to new offset failed");
+return FALSE;
+}
+cache->currentoffset = offset;
+}
+written = write (registry->cache_file, data, length);
+if (written != length) {
+GST_ERROR ("Failed to write to cache file");
+}
+cache->currentoffset += written;
+return written;
+}
+static gboolean
+gst_registry_binary_cache_finish (GstRegistry * registry,
+BinaryRegistryCache * cache, gboolean success)
+{
+/* only fsync if we're actually going to use and rename the file below */
+if (success && fsync (registry->cache_file) < 0)
+goto fsync_failed;
+if (close (registry->cache_file) < 0)
+goto close_failed;
+if (success) {
+/* Only do the rename if we wrote the entire file successfully */
+if (g_rename (cache->tmp_location, cache->location) < 0)
+goto rename_failed;
+}
+g_free (cache->tmp_location);
+g_free (cache);
+GST_INFO ("Wrote binary registry cache");
+return TRUE;
+/* ERRORS */
+fail_after_close:
+{
+g_unlink (cache->tmp_location);
+g_free (cache->tmp_location);
+g_free (cache);
+return FALSE;
+}
+fsync_failed:
+{
+GST_ERROR ("fsync() failed: %s", g_strerror (errno));
+goto fail_after_close;
+}
+close_failed:
+{
+GST_ERROR ("close() failed: %s", g_strerror (errno));
+goto fail_after_close;
+}
+rename_failed:
+{
+GST_ERROR ("g_rename() failed: %s", g_strerror (errno));
+goto fail_after_close;
+}
+}
 #endif
-/* Registry saving */
 /*
-* gst_registry_binary_write:
+* gst_registry_binary_write_chunk:
 *
 * Write from a memory location to the registry cache file
 *
 * Returns: %TRUE for success
 */
 inline static gboolean
-gst_registry_binary_write (GstRegistry * registry, const void *mem,
+gst_registry_binary_write_chunk (GstRegistry * registry,
+BinaryRegistryCache * cache, const void *mem,
 const gssize size, unsigned long *file_position, gboolean align)
 {
-#if !GST_HAVE_UNALIGNED_ACCESS
+gchar padder[ALIGNMENT] = { 0, };
-gchar padder[] = { 0, 0, 0, 0 };
 int padsize = 0;
 /* Padding to insert the struct that requiere word alignment */
-if ((align) && (alignment32 (*file_position) != 0)) {
+if ((align) && (alignment (*file_position) != 0)) {
-padsize = 4 - alignment32 (*file_position);
+padsize = ALIGNMENT - alignment (*file_position);
-if (write (registry->cache_file, padder, padsize) != padsize) {
+if (gst_registry_binary_cache_write (registry, cache, *file_position,
+padder, padsize) != padsize) {
 GST_ERROR ("Failed to write binary registry padder");
 return FALSE;
 }
-*file_position = *file_position + padsize;
+*file_position += padsize;
 }
-#endif
+if (gst_registry_binary_cache_write (registry, cache, *file_position,
-if (write (registry->cache_file, mem, size) != size) {
+mem, size) != size) {
 GST_ERROR ("Failed to write binary registry element");
 return FALSE;
 }
-*file_position = *file_position + size;
+*file_position += size;
 return TRUE;
 }
 /*
 * gstreamer major/minor version
 */
 inline static gboolean
 gst_registry_binary_initialize_magic (GstBinaryRegistryMagic * m)
 {
+memset (m, 0, sizeof (GstBinaryRegistryMagic));
 if (!strncpy (m->magic, GST_MAGIC_BINARY_REGISTRY_STR,
 GST_MAGIC_BINARY_REGISTRY_LEN)
-|| !strncpy (m->version, GST_MAJORMINOR, GST_MAGIC_BINARY_VERSION_LEN)) {
+|| !strncpy (m->version, GST_MAGIC_BINARY_VERSION_STR,
+GST_MAGIC_BINARY_VERSION_LEN)) {
 GST_ERROR ("Failed to write magic to the registry magic structure");
 return FALSE;
 }
 return TRUE;
 }
 /*
 */
 inline static gboolean
 gst_registry_binary_save_const_string (GList ** list, const gchar * str)
 {
 GstBinaryChunk *chunk;
+if (G_UNLIKELY (str == NULL)) {
+GST_ERROR ("unexpected NULL string in plugin or plugin feature data");
+str = "";
+}
 chunk = g_malloc (sizeof (GstBinaryChunk));
 chunk->data = (gpointer) str;
 chunk->size = strlen ((gchar *) chunk->data) + 1;
 chunk->flags = GST_BINARY_REGISTRY_FLAG_CONST;
 GstStaticPadTemplate * template)
 {
 GstBinaryPadTemplate *pt;
 GstBinaryChunk *chk;
-pt = g_malloc (sizeof (GstBinaryPadTemplate));
+pt = g_malloc0 (sizeof (GstBinaryPadTemplate));
 chk = gst_registry_binary_make_data (pt, sizeof (GstBinaryPadTemplate));
 pt->presence = template->presence;
 pt->direction = template->direction;
 if (GST_IS_ELEMENT_FACTORY (feature)) {
 GstBinaryElementFactory *ef;
 GstElementFactory *factory = GST_ELEMENT_FACTORY (feature);
-ef = g_malloc (sizeof (GstBinaryElementFactory));
+ef = g_malloc0 (sizeof (GstBinaryElementFactory));
 chk = gst_registry_binary_make_data (ef, sizeof (GstBinaryElementFactory));
 ef->npadtemplates = ef->ninterfaces = ef->nuriprotocols = 0;
 pf = (GstBinaryPluginFeature *) ef;
 /* save interfaces */
 gst_registry_binary_save_const_string (list, (gchar *) walk->data);
 }
 GST_DEBUG ("Saved %d Interfaces", ef->ninterfaces);
 /* save uritypes */
 if (GST_URI_TYPE_IS_VALID (factory->uri_type)) {
-if (factory->uri_protocols) {
+if (factory->uri_protocols && *factory->uri_protocols) {
 GstBinaryChunk *subchk;
 gchar **protocol;
 subchk =
 gst_registry_binary_make_data (&factory->uri_type,
 gst_registry_binary_save_const_string (list, factory->details.klass);
 gst_registry_binary_save_const_string (list, factory->details.longname);
 } else if (GST_IS_TYPE_FIND_FACTORY (feature)) {
 GstBinaryTypeFindFactory *tff;
 GstTypeFindFactory *factory = GST_TYPE_FIND_FACTORY (feature);
-gchar *str;
+tff = g_malloc0 (sizeof (GstBinaryTypeFindFactory));
-/* we copy the caps here so we can simplify them before saving. This is a lot
-* faster when loading them later on */
-GstCaps *copy = gst_caps_copy (factory->caps);
-tff = g_malloc (sizeof (GstBinaryTypeFindFactory));
 chk =
 gst_registry_binary_make_data (tff, sizeof (GstBinaryTypeFindFactory));
 tff->nextensions = 0;
 pf = (GstBinaryPluginFeature *) tff;
 gst_registry_binary_save_const_string (list,
 factory->extensions[tff->nextensions++]);
 }
 }
 /* save caps */
-gst_caps_do_simplify (copy);
+if (factory->caps) {
-str = gst_caps_to_string (copy);
+GstCaps *copy = gst_caps_copy (factory->caps);
-gst_caps_unref (copy);
+gchar *str;
-gst_registry_binary_save_string (list, str);
-}
+/* we copy the caps here so we can simplify them
-#ifndef GST_DISABLE_INDEX
+* before saving. This is a lot faster when loading
-else if (GST_IS_INDEX_FACTORY (feature)) {
+* them later on */
+gst_caps_do_simplify (copy);
+str = gst_caps_to_string (copy);
+gst_caps_unref (copy);
+gst_registry_binary_save_string (list, str);
+} else {
+gst_registry_binary_save_const_string (list, "");
+}
+} else if (GST_IS_INDEX_FACTORY (feature)) {
 GstIndexFactory *factory = GST_INDEX_FACTORY (feature);
-pf = g_malloc (sizeof (GstBinaryPluginFeature));
+pf = g_malloc0 (sizeof (GstBinaryPluginFeature));
 chk = gst_registry_binary_make_data (pf, sizeof (GstBinaryPluginFeature));
 pf->rank = feature->rank;
 /* pack element factory strings */
 gst_registry_binary_save_const_string (list, factory->longdesc);
-}
+} else {
-#endif
-else {
 GST_WARNING ("unhandled feature type '%s'", type_name);
 }
 if (pf) {
 pf->rank = feature->rank;
 g_free (chk);
 g_free (pf);
 return FALSE;
 }
+static gboolean
+gst_registry_binary_save_plugin_dep (GList ** list, GstPluginDep * dep)
+{
+GstBinaryDep *ed;
+GstBinaryChunk *chk;
+gchar **s;
+ed = g_new0 (GstBinaryDep, 1);
+chk = gst_registry_binary_make_data (ed, sizeof (GstBinaryDep));
+ed->flags = dep->flags;
+ed->n_env_vars = 0;
+ed->n_paths = 0;
+ed->n_names = 0;
+ed->env_hash = dep->env_hash;
+ed->stat_hash = dep->stat_hash;
+for (s = dep->env_vars; s != NULL && *s != NULL; ++s, ++ed->n_env_vars)
+gst_registry_binary_save_string (list, g_strdup (*s));
+for (s = dep->paths; s != NULL && *s != NULL; ++s, ++ed->n_paths)
+gst_registry_binary_save_string (list, g_strdup (*s));
+for (s = dep->names; s != NULL && *s != NULL; ++s, ++ed->n_names)
+gst_registry_binary_save_string (list, g_strdup (*s));
+*list = g_list_prepend (*list, chk);
+GST_LOG ("Saved external plugin dependency");
+return TRUE;
+}
 /*
 * gst_registry_binary_save_plugin:
 *
 * Adapt a GstPlugin to our GstBinaryPluginElement structure, and write it to
 GstBinaryPluginElement *pe;
 GstBinaryChunk *chk;
 GList *plugin_features = NULL;
 GList *walk;
-pe = g_malloc (sizeof (GstBinaryPluginElement));
+pe = g_malloc0 (sizeof (GstBinaryPluginElement));
 chk = gst_registry_binary_make_data (pe, sizeof (GstBinaryPluginElement));
 pe->file_size = plugin->file_size;
 pe->file_mtime = plugin->file_mtime;
+pe->n_deps = 0;
 pe->nfeatures = 0;
+/* pack external deps */
+for (walk = plugin->priv->deps; walk != NULL; walk = walk->next) {
+if (!gst_registry_binary_save_plugin_dep (list, walk->data)) {
+GST_ERROR ("Could not save external plugin dependency, aborting.");
+goto fail;
+}
+++pe->n_deps;
+}
 /* pack plugin features */
 plugin_features =
 gst_registry_get_feature_list_by_plugin (registry, plugin->desc.name);
 for (walk = plugin_features; walk; walk = g_list_next (walk), pe->nfeatures++) {
 if (!gst_registry_binary_save_feature (list, feature)) {
 GST_ERROR ("Can't fill plugin feature, aborting.");
 goto fail;
 }
 }
-GST_DEBUG ("Save plugin '%s' with %d features", plugin->desc.name,
+GST_DEBUG ("Save plugin '%s' with %d feature(s)", plugin->desc.name,
 pe->nfeatures);
 gst_plugin_feature_list_free (plugin_features);
+/* pack cache data */
+if (plugin->priv->cache_data) {
+gchar *cache_str = gst_structure_to_string (plugin->priv->cache_data);
+gst_registry_binary_save_string (list, cache_str);
+} else {
+gst_registry_binary_save_const_string (list, "");
+}
 /* pack plugin element strings */
 gst_registry_binary_save_const_string (list, plugin->desc.origin);
 gst_registry_binary_save_const_string (list, plugin->desc.package);
 gst_registry_binary_save_const_string (list, plugin->desc.source);
 g_free (chk);
 g_free (pe);
 return FALSE;
 }
 /**
 * gst_registry_binary_write_cache:
 * @registry: a #GstRegistry
 * @location: a filename
 *
 gboolean
 gst_registry_binary_write_cache (GstRegistry * registry, const char *location)
 {
 GList *walk;
-gchar *tmp_location;
+GstBinaryRegistryMagic magic;
-GstBinaryRegistryMagic *magic;
-GstBinaryChunk *magic_chunk;
 GList *to_write = NULL;
 unsigned long file_position = 0;
+BinaryRegistryCache *cache;
 GST_INFO ("Building binary registry cache image");
 g_return_val_if_fail (GST_IS_REGISTRY (registry), FALSE);
-tmp_location = g_strconcat (location, ".tmpXXXXXX", NULL);
-registry->cache_file = g_mkstemp (tmp_location);
+if (!gst_registry_binary_initialize_magic (&magic))
-if (registry->cache_file == -1) {
-gchar *dir;
-/* oops, I bet the directory doesn't exist */
-dir = g_path_get_dirname (location);
-g_mkdir_with_parents (dir, 0777);
-g_free (dir);
-/* the previous g_mkstemp call overwrote the XXXXXX placeholder ... */
-g_free (tmp_location);
-tmp_location = g_strconcat (location, ".tmpXXXXXX", NULL);
-registry->cache_file = g_mkstemp (tmp_location);
-if (registry->cache_file == -1) {
-GST_DEBUG ("g_mkstemp() failed: %s", g_strerror (errno));
-g_free (tmp_location);
-return FALSE;
-}
-}
-magic = g_malloc (sizeof (GstBinaryRegistryMagic));
-if (!gst_registry_binary_initialize_magic (magic))
 goto fail;
-magic_chunk = g_malloc (sizeof (GstBinaryChunk));
-magic_chunk->data = magic;
-magic_chunk->size = sizeof (GstBinaryRegistryMagic);
-magic_chunk->flags = GST_BINARY_REGISTRY_FLAG_NONE;
-magic_chunk->align = TRUE;
 /* iterate trough the list of plugins and fit them into binary structures */
 for (walk = registry->plugins; walk; walk = g_list_next (walk)) {
 GstPlugin *plugin = GST_PLUGIN (walk->data);
 if (!plugin->filename)
 continue;
 if (plugin->flags & GST_PLUGIN_FLAG_CACHED) {
-int ret;
 struct stat statbuf;
-ret = g_stat (plugin->filename, &statbuf);
+if (g_stat (plugin->filename, &statbuf) < 0 ||
-if ((ret = g_stat (plugin->filename, &statbuf)) < 0 ||
 plugin->file_mtime != statbuf.st_mtime ||
 plugin->file_size != statbuf.st_size)
 continue;
 }
 if (!gst_registry_binary_save_plugin (&to_write, registry, plugin)) {
 GST_ERROR ("Can't write binary plugin information for \"%s\"",
 plugin->filename);
 }
 }
-to_write = g_list_prepend (to_write, magic_chunk);
 GST_INFO ("Writing binary registry cache");
+cache = gst_registry_binary_cache_init (registry, location);
+if (!cache)
+goto fail_free_list;
+/* write magic */
+if (gst_registry_binary_cache_write (registry, cache, file_position,
+&magic, sizeof (GstBinaryRegistryMagic)) !=
+sizeof (GstBinaryRegistryMagic)) {
+GST_ERROR ("Failed to write binary registry magic");
+goto fail_free_list;
+}
+file_position += sizeof (GstBinaryRegistryMagic);
 /* write out data chunks */
 for (walk = to_write; walk; walk = g_list_next (walk)) {
 GstBinaryChunk *cur = walk->data;
-if (!gst_registry_binary_write (registry, cur->data, cur->size,
+if (!gst_registry_binary_write_chunk (registry, cache, cur->data, cur->size,
 &file_position, cur->align)) {
+goto fail_free_list;
+}
+if (!(cur->flags & GST_BINARY_REGISTRY_FLAG_CONST))
+g_free (cur->data);
+g_free (cur);
+walk->data = NULL;
+}
+g_list_free (to_write);
+if (!gst_registry_binary_cache_finish (registry, cache, TRUE))
+return FALSE;
+return TRUE;
+/* Errors */
+fail_free_list:
+{
+for (walk = to_write; walk; walk = g_list_next (walk)) {
+GstBinaryChunk *cur = walk->data;
 if (!(cur->flags & GST_BINARY_REGISTRY_FLAG_CONST))
 g_free (cur->data);
 g_free (cur);
-g_list_free (to_write);
+}
-goto fail;
+g_list_free (to_write);
-}
-if (!(cur->flags & GST_BINARY_REGISTRY_FLAG_CONST))
+if (cache)
-g_free (cur->data);
+(void) gst_registry_binary_cache_finish (registry, cache, FALSE);
-g_free (cur);
+/* fall through */
 }
-g_list_free (to_write);
-if (close (registry->cache_file) < 0)
-goto close_failed;
-if (g_file_test (tmp_location, G_FILE_TEST_EXISTS)) {
-#ifdef WIN32
-g_remove (location);
-#endif
-if (g_rename (tmp_location, location) < 0)
-goto rename_failed;
-} else {
-/* FIXME: shouldn't we return FALSE here? */
-}
-g_free (tmp_location);
-GST_INFO ("Wrote binary registry cache");
-return TRUE;
-/* Errors */
 fail:
 {
-(void) close (registry->cache_file);
-/* fall through */
-}
-fail_after_close:
-{
-g_remove (tmp_location);
-g_free (tmp_location);
 return FALSE;
-}
-close_failed:
-{
-GST_ERROR ("close() failed: %s", g_strerror (errno));
-goto fail_after_close;
-}
-rename_failed:
-{
-GST_ERROR ("g_rename() failed: %s", g_strerror (errno));
-goto fail_after_close;
 }
 }
 /* Registry loading */
 /*
 * gst_registry_binary_check_magic:
 *
 * Check GstBinaryRegistryMagic validity.
-* Return FALSE if something is wrong
+* Return < 0 if something is wrong, -2 means
-*/
+* that just the version of the registry is out of
-static gboolean
+* date, -1 is a general failure.
-gst_registry_binary_check_magic (gchar ** in)
+*/
+static gint
+gst_registry_binary_check_magic (gchar ** in, gsize size)
 {
 GstBinaryRegistryMagic *m;
-align32 (*in);
+align (*in);
 GST_DEBUG ("Reading/casting for GstBinaryRegistryMagic at address %p", *in);
-unpack_element (*in, m, GstBinaryRegistryMagic);
+unpack_element (*in, m, GstBinaryRegistryMagic, (*in + size), fail);
-if (m == NULL || m->magic == NULL || m->version == NULL) {
-GST_WARNING ("Binary registry magic structure is broken");
-return FALSE;
-}
 if (strncmp (m->magic, GST_MAGIC_BINARY_REGISTRY_STR,
 GST_MAGIC_BINARY_REGISTRY_LEN) != 0) {
 GST_WARNING
 ("Binary registry magic is different : %02x%02x%02x%02x != %02x%02x%02x%02x",
 GST_MAGIC_BINARY_REGISTRY_STR[0] & 0xff,
 GST_MAGIC_BINARY_REGISTRY_STR[1] & 0xff,
 GST_MAGIC_BINARY_REGISTRY_STR[2] & 0xff,
 GST_MAGIC_BINARY_REGISTRY_STR[3] & 0xff, m->magic[0] & 0xff,
 m->magic[1] & 0xff, m->magic[2] & 0xff, m->magic[3] & 0xff);
-return FALSE;
+return -1;
 }
-if (strncmp (m->version, GST_MAJORMINOR, GST_MAGIC_BINARY_VERSION_LEN)) {
+if (strncmp (m->version, GST_MAGIC_BINARY_VERSION_STR,
+GST_MAGIC_BINARY_VERSION_LEN)) {
 GST_WARNING ("Binary registry magic version is different : %s != %s",
-GST_MAJORMINOR, m->version);
+GST_MAGIC_BINARY_VERSION_STR, m->version);
-return FALSE;
+return -2;
 }
-return TRUE;
+return 0;
+fail:
+GST_WARNING ("Not enough data for binary registry magic structure");
+return -1;
 }
 /*
 * gst_registry_binary_load_pad_template:
 * Make a new GstStaticPadTemplate from current GstBinaryPadTemplate structure
 *
 * Returns: new GstStaticPadTemplate
 */
 static gboolean
-gst_registry_binary_load_pad_template (GstElementFactory * factory, gchar ** in)
+gst_registry_binary_load_pad_template (GstElementFactory * factory, gchar ** in,
+gchar * end)
 {
 GstBinaryPadTemplate *pt;
-GstStaticPadTemplate *template;
+GstStaticPadTemplate *template = NULL;
-align32 (*in);
+align (*in);
 GST_DEBUG ("Reading/casting for GstBinaryPadTemplate at address %p", *in);
-unpack_element (*in, pt, GstBinaryPadTemplate);
+unpack_element (*in, pt, GstBinaryPadTemplate, end, fail);
 template = g_new0 (GstStaticPadTemplate, 1);
 template->presence = pt->presence;
 template->direction = pt->direction;
 /* unpack pad template strings */
-unpack_const_string (*in, template->name_template);
+unpack_const_string (*in, template->name_template, end, fail);
-unpack_string (*in, template->static_caps.string);
+unpack_string (*in, template->static_caps.string, end, fail);
 __gst_element_factory_add_static_pad_template (factory, template);
 GST_DEBUG ("Added pad_template %s", template->name_template);
 return TRUE;
+fail:
+GST_INFO ("Reading pad template failed");
+g_free (template);
+return FALSE;
 }
 /*
 * gst_registry_binary_load_feature:
 *
 * Returns: new GstPluginFeature
 */
 static gboolean
 gst_registry_binary_load_feature (GstRegistry * registry, gchar ** in,
-const gchar * plugin_name)
+gchar * end, const gchar * plugin_name)
 {
 GstBinaryPluginFeature *pf = NULL;
-GstPluginFeature *feature;
+GstPluginFeature *feature = NULL;
 gchar *type_name = NULL, *str;
 GType type;
 guint i;
 /* unpack plugin feature strings */
-unpack_string (*in, type_name);
+unpack_string (*in, type_name, end, fail);
-if (!type_name || !*(type_name))
+if (G_UNLIKELY (!type_name)) {
+GST_ERROR ("No feature type name");
 return FALSE;
+}
 GST_DEBUG ("Plugin '%s' feature typename : '%s'", plugin_name, type_name);
-if (!(type = g_type_from_name (type_name))) {
+if (G_UNLIKELY (!(type = g_type_from_name (type_name)))) {
 GST_ERROR ("Unknown type from typename '%s' for plugin '%s'", type_name,
 plugin_name);
+g_free (type_name);
 return FALSE;
 }
-if ((feature = g_object_new (type, NULL)) == NULL) {
+if (G_UNLIKELY ((feature = g_object_new (type, NULL)) == NULL)) {
 GST_ERROR ("Can't create feature from type");
+g_free (type_name);
 return FALSE;
 }
-if (!GST_IS_PLUGIN_FEATURE (feature)) {
+if (G_UNLIKELY (!GST_IS_PLUGIN_FEATURE (feature))) {
-GST_ERROR ("typename : '%s' is not a plgin feature", type_name);
+GST_ERROR ("typename : '%s' is not a plugin feature", type_name);
 goto fail;
 }
 /* unpack more plugin feature strings */
-unpack_string (*in, feature->name);
+unpack_string (*in, feature->name, end, fail);
 if (GST_IS_ELEMENT_FACTORY (feature)) {
 GstBinaryElementFactory *ef;
-GstElementFactory *factory = GST_ELEMENT_FACTORY (feature);
+guint n;
+GstElementFactory *factory = GST_ELEMENT_FACTORY_CAST (feature);
-align32 (*in);
+align (*in);
 GST_LOG ("Reading/casting for GstBinaryElementFactory at address %p", *in);
-unpack_element (*in, ef, GstBinaryElementFactory);
+unpack_element (*in, ef, GstBinaryElementFactory, end, fail);
 pf = (GstBinaryPluginFeature *) ef;
 /* unpack element factory strings */
-unpack_string (*in, factory->details.longname);
+unpack_string (*in, factory->details.longname, end, fail);
-unpack_string (*in, factory->details.klass);
+unpack_string (*in, factory->details.klass, end, fail);
-unpack_string (*in, factory->details.description);
+unpack_string (*in, factory->details.description, end, fail);
-unpack_string (*in, factory->details.author);
+unpack_string (*in, factory->details.author, end, fail);
+n = ef->npadtemplates;
 GST_DEBUG ("Element factory : '%s' with npadtemplates=%d",
-factory->details.longname, ef->npadtemplates);
+factory->details.longname, n);
 /* load pad templates */
-for (i = 0; i < ef->npadtemplates; i++) {
+for (i = 0; i < n; i++) {
-if (!gst_registry_binary_load_pad_template (factory, in)) {
+if (G_UNLIKELY (!gst_registry_binary_load_pad_template (factory, in,
+end))) {
 GST_ERROR ("Error while loading binary pad template");
 goto fail;
 }
 }
 /* load uritypes */
-if (ef->nuriprotocols) {
+if (G_UNLIKELY ((n = ef->nuriprotocols))) {
-GST_DEBUG ("Reading %d UriTypes at address %p", ef->nuriprotocols, *in);
+GST_DEBUG ("Reading %d UriTypes at address %p", n, *in);
-align32 (*in);
+align (*in);
 factory->uri_type = *((guint *) * in);
 *in += sizeof (factory->uri_type);
-//unpack_element(*in, &factory->uri_type, factory->uri_type);
+/*unpack_element(*in, &factory->uri_type, factory->uri_type, end, fail); */
-factory->uri_protocols = g_new0 (gchar *, ef->nuriprotocols + 1);
+factory->uri_protocols = g_new0 (gchar *, n + 1);
-for (i = 0; i < ef->nuriprotocols; i++) {
+for (i = 0; i < n; i++) {
-unpack_string (*in, str);
+unpack_string (*in, str, end, fail);
 factory->uri_protocols[i] = str;
 }
 }
 /* load interfaces */
-GST_DEBUG ("Reading %d Interfaces at address %p", ef->ninterfaces, *in);
+if (G_UNLIKELY ((n = ef->ninterfaces))) {
-for (i = 0; i < ef->ninterfaces; i++) {
+GST_DEBUG ("Reading %d Interfaces at address %p", n, *in);
-unpack_string (*in, str);
+for (i = 0; i < n; i++) {
-__gst_element_factory_add_interface (factory, str);
+unpack_string (*in, str, end, fail);
-g_free (str);
+__gst_element_factory_add_interface (factory, str);
+g_free (str);
+}
 }
 } else if (GST_IS_TYPE_FIND_FACTORY (feature)) {
 GstBinaryTypeFindFactory *tff;
 GstTypeFindFactory *factory = GST_TYPE_FIND_FACTORY (feature);
-align32 (*in);
+align (*in);
 GST_DEBUG ("Reading/casting for GstBinaryPluginFeature at address %p", *in);
-unpack_element (*in, tff, GstBinaryTypeFindFactory);
+unpack_element (*in, tff, GstBinaryTypeFindFactory, end, fail);
 pf = (GstBinaryPluginFeature *) tff;
 /* load caps */
-unpack_string (*in, str);
+unpack_string (*in, str, end, fail);
-factory->caps = gst_caps_from_string (str);
+factory->caps = (str && *str) ? gst_caps_from_string (str) : NULL;
 g_free (str);
 /* load extensions */
 if (tff->nextensions) {
 GST_DEBUG ("Reading %d Typefind extensions at address %p",
 tff->nextensions, *in);
 factory->extensions = g_new0 (gchar *, tff->nextensions + 1);
 for (i = 0; i < tff->nextensions; i++) {
-unpack_string (*in, str);
+unpack_string (*in, str, end, fail);
 factory->extensions[i] = str;
 }
 }
-}
+} else if (GST_IS_INDEX_FACTORY (feature)) {
-#ifndef GST_DISABLE_INDEX
-else if (GST_IS_INDEX_FACTORY (feature)) {
 GstIndexFactory *factory = GST_INDEX_FACTORY (feature);
-align32 (*in);
+align (*in);
 GST_DEBUG ("Reading/casting for GstBinaryPluginFeature at address %p", *in);
-unpack_element (*in, pf, GstBinaryPluginFeature);
+unpack_element (*in, pf, GstBinaryPluginFeature, end, fail);
 /* unpack index factory strings */
-unpack_string (*in, factory->longdesc);
+unpack_string (*in, factory->longdesc, end, fail);
-}
+} else {
-#endif
+GST_WARNING ("unhandled factory type : %s", G_OBJECT_TYPE_NAME (feature));
+goto fail;
+}
 feature->rank = pf->rank;
 /* should already be the interned string, but better make sure */
 feature->plugin_name = g_intern_string (plugin_name);
 g_free (type_name);
 return TRUE;
 /* Errors */
 fail:
+GST_INFO ("Reading plugin feature failed");
 g_free (type_name);
-if (GST_IS_OBJECT (feature))
+if (feature) {
-gst_object_unref (feature);
+if (GST_IS_OBJECT (feature))
-else
+gst_object_unref (feature);
-g_object_unref (feature);
+else
+g_object_unref (feature);
+}
 return FALSE;
 }
+static gchar **
+gst_registry_binary_load_plugin_dep_strv (gchar ** in, gchar * end, guint n)
+{
+gchar **arr;
+if (n == 0)
+return NULL;
+arr = g_new0 (gchar *, n + 1);
+while (n > 0) {
+unpack_string (*in, arr[n - 1], end, fail);
+--n;
+}
+return arr;
+fail:
+GST_INFO ("Reading plugin dependency strings failed");
+return NULL;
+}
+static gboolean
+gst_registry_binary_load_plugin_dep (GstPlugin * plugin, gchar ** in,
+gchar * end)
+{
+GstPluginDep *dep;
+GstBinaryDep *d;
+gchar **s;
+align (*in);
+GST_LOG_OBJECT (plugin, "Unpacking GstBinaryDep from %p", *in);
+unpack_element (*in, d, GstBinaryDep, end, fail);
+dep = g_new0 (GstPluginDep, 1);
+dep->env_hash = d->env_hash;
+dep->stat_hash = d->stat_hash;
+dep->flags = d->flags;
+dep->names = gst_registry_binary_load_plugin_dep_strv (in, end, d->n_names);
+dep->paths = gst_registry_binary_load_plugin_dep_strv (in, end, d->n_paths);
+dep->env_vars =
+gst_registry_binary_load_plugin_dep_strv (in, end, d->n_env_vars);
+plugin->priv->deps = g_list_append (plugin->priv->deps, dep);
+GST_DEBUG_OBJECT (plugin, "Loaded external plugin dependency from registry: "
+"env_hash: %08x, stat_hash: %08x", dep->env_hash, dep->stat_hash);
+for (s = dep->env_vars; s != NULL && *s != NULL; ++s)
+GST_LOG_OBJECT (plugin, " evar: %s", *s);
+for (s = dep->paths; s != NULL && *s != NULL; ++s)
+GST_LOG_OBJECT (plugin, " path: %s", *s);
+for (s = dep->names; s != NULL && *s != NULL; ++s)
+GST_LOG_OBJECT (plugin, " name: %s", *s);
+return TRUE;
+fail:
+GST_INFO ("Reading plugin dependency failed");
+return FALSE;
+}
 /*
 * gst_registry_binary_load_plugin:
 *
 * Make a new GstPlugin from current GstBinaryPluginElement structure
 * and save it to the GstRegistry. Return an offset to the next
 * GstBinaryPluginElement structure.
 */
 static gboolean
-gst_registry_binary_load_plugin (GstRegistry * registry, gchar ** in)
+gst_registry_binary_load_plugin (GstRegistry * registry, gchar ** in,
+gchar * end)
 {
 GstBinaryPluginElement *pe;
 GstPlugin *plugin = NULL;
-guint i;
+gchar *cache_str = NULL;
+guint i, n;
-align32 (*in);
+align (*in);
 GST_LOG ("Reading/casting for GstBinaryPluginElement at address %p", *in);
-unpack_element (*in, pe, GstBinaryPluginElement);
+unpack_element (*in, pe, GstBinaryPluginElement, end, fail);
-if (pe->nfeatures < 0) {
-GST_ERROR ("The number of feature structure is not valid !");
-return FALSE;
-}
-if (pe->file_mtime < 0 || pe->file_size < 0) {
-GST_ERROR ("Plugin time or file size is not valid !");
-return FALSE;
-}
 plugin = g_object_new (GST_TYPE_PLUGIN, NULL);
 /* TODO: also set GST_PLUGIN_FLAG_CONST */
 plugin->flags |= GST_PLUGIN_FLAG_CACHED;
 plugin->file_mtime = pe->file_mtime;
 plugin->file_size = pe->file_size;
 /* unpack plugin element strings */
-unpack_const_string (*in, plugin->desc.name);
+unpack_const_string (*in, plugin->desc.name, end, fail);
-unpack_string (*in, plugin->desc.description);
+unpack_string (*in, plugin->desc.description, end, fail);
-unpack_string (*in, plugin->filename);
+unpack_string (*in, plugin->filename, end, fail);
-unpack_const_string (*in, plugin->desc.version);
+unpack_const_string (*in, plugin->desc.version, end, fail);
-unpack_const_string (*in, plugin->desc.license);
+unpack_const_string (*in, plugin->desc.license, end, fail);
-unpack_const_string (*in, plugin->desc.source);
+unpack_const_string (*in, plugin->desc.source, end, fail);
-unpack_const_string (*in, plugin->desc.package);
+unpack_const_string (*in, plugin->desc.package, end, fail);
-unpack_const_string (*in, plugin->desc.origin);
+unpack_const_string (*in, plugin->desc.origin, end, fail);
-GST_LOG ("read strings for '%s'", plugin->desc.name);
+GST_LOG ("read strings for name='%s'", plugin->desc.name);
+GST_LOG ("  desc.description='%s'", plugin->desc.description);
+GST_LOG ("  filename='%s'", plugin->filename);
+GST_LOG ("  desc.version='%s'", plugin->desc.version);
+GST_LOG ("  desc.license='%s'", plugin->desc.license);
+GST_LOG ("  desc.source='%s'", plugin->desc.source);
+GST_LOG ("  desc.package='%s'", plugin->desc.package);
+GST_LOG ("  desc.origin='%s'", plugin->desc.origin);
+/* unpack cache data */
+unpack_string (*in, cache_str, end, fail);
+if (*cache_str) {
+plugin->priv->cache_data = gst_structure_from_string (cache_str, NULL);
+}
+g_free (cache_str);
 plugin->basename = g_path_get_basename (plugin->filename);
+/* Takes ownership of plugin */
 gst_registry_add_plugin (registry, plugin);
-GST_INFO ("Added plugin '%s' plugin with %d features from binary registry",
+n = pe->nfeatures;
-plugin->desc.name, pe->nfeatures);
+GST_DEBUG ("Added plugin '%s' plugin with %d features from binary registry",
-for (i = 0; i < pe->nfeatures; i++) {
+plugin->desc.name, n);
-if (!gst_registry_binary_load_feature (registry, in, plugin->desc.name)) {
+/* Load plugin features */
+for (i = 0; i < n; i++) {
+if (G_UNLIKELY (!gst_registry_binary_load_feature (registry, in, end,
+plugin->desc.name))) {
 GST_ERROR ("Error while loading binary feature");
+gst_registry_remove_plugin (registry, plugin);
+goto fail;
+}
+}
+/* Load external plugin dependencies */
+for (i = 0; i < pe->n_deps; ++i) {
+if (G_UNLIKELY (!gst_registry_binary_load_plugin_dep (plugin, in, end))) {
+GST_ERROR_OBJECT (plugin, "Could not read external plugin dependency");
+gst_registry_remove_plugin (registry, plugin);
 goto fail;
 }
 }
 return TRUE;
 /* Errors */
 fail:
-gst_object_unref (plugin);
+GST_INFO ("Reading plugin failed");
 return FALSE;
 }
 /**
 * Returns: %TRUE on success.
 */
 #ifdef __SYMBIAN32__
 EXPORT_C
 #endif
 gboolean
 gst_registry_binary_read_cache (GstRegistry * registry, const char *location)
 {
 GMappedFile *mapped = NULL;
-GTimer *timer = NULL;
 gchar *contents = NULL;
 gchar *in = NULL;
-gdouble seconds;
 gsize size;
 GError *err = NULL;
 gboolean res = FALSE;
+gint check_magic_result;
+#ifndef GST_DISABLE_GST_DEBUG
+GTimer *timer = NULL;
+gdouble seconds;
+#endif
 /* make sure these types exist */
 GST_TYPE_ELEMENT_FACTORY;
 GST_TYPE_TYPE_FIND_FACTORY;
-#ifndef GST_DISABLE_INDEX
 GST_TYPE_INDEX_FACTORY;
+#ifndef GST_DISABLE_GST_DEBUG
+timer = g_timer_new ();
 #endif
-timer = g_timer_new ();
 mapped = g_mapped_file_new (location, FALSE, &err);
-if (err != NULL) {
+if (G_UNLIKELY (err != NULL)) {
 GST_INFO ("Unable to mmap file %s : %s", location, err->message);
 g_error_free (err);
 err = NULL;
 g_file_get_contents (location, &contents, &size, &err);
 if (err != NULL) {
 GST_INFO ("Unable to read file %s : %s", location, err->message);
+#ifndef GST_DISABLE_GST_DEBUG
 g_timer_destroy (timer);
+#endif
 g_error_free (err);
 return FALSE;
 }
 } else {
-if ((contents = g_mapped_file_get_contents (mapped)) == NULL) {
+if (G_UNLIKELY ((contents = g_mapped_file_get_contents (mapped)) == NULL)) {
 GST_ERROR ("Can't load file %s : %s", location, g_strerror (errno));
 goto Error;
 }
 /* check length for header */
 size = g_mapped_file_get_length (mapped);
 }
 /* in is a cursor pointer, we initialize it with the begin of registry and is updated on each read */
 in = contents;
 GST_DEBUG ("File data at address %p", in);
-if (size < sizeof (GstBinaryRegistryMagic)) {
+if (G_UNLIKELY (size < sizeof (GstBinaryRegistryMagic))) {
 GST_ERROR ("No or broken registry header");
 goto Error;
 }
 /* check if header is valid */
-if (!gst_registry_binary_check_magic (&in)) {
+if (G_UNLIKELY ((check_magic_result =
-GST_ERROR
+gst_registry_binary_check_magic (&in, size)) < 0)) {
-("Binary registry type not recognized (invalid magic) for file at %s",
-location);
+if (check_magic_result == -1)
+GST_ERROR
+("Binary registry type not recognized (invalid magic) for file at %s",
+location);
 goto Error;
 }
 /* check if there are plugins in the file */
+if (G_UNLIKELY (!(((gsize) in + sizeof (GstBinaryPluginElement)) <
-if (!(((gsize) in + sizeof (GstBinaryPluginElement)) <
+(gsize) contents + size))) {
-(gsize) contents + size)) {
 GST_INFO ("No binary plugins structure to read");
 /* empty file, this is not an error */
 } else {
+gchar *end = contents + size;
+/* read as long as we still have space for a GstBinaryPluginElement */
 for (;
 ((gsize) in + sizeof (GstBinaryPluginElement)) <
 (gsize) contents + size;) {
 GST_DEBUG ("reading binary registry %" G_GSIZE_FORMAT "(%x)/%"
 G_GSIZE_FORMAT, (gsize) in - (gsize) contents,
 (guint) ((gsize) in - (gsize) contents), size);
-if (!gst_registry_binary_load_plugin (registry, &in)) {
+if (!gst_registry_binary_load_plugin (registry, &in, end)) {
-GST_ERROR ("Problem while reading binary registry");
+GST_ERROR ("Problem while reading binary registry %s", location);
 goto Error;
 }
 }
 }
+#ifndef GST_DISABLE_GST_DEBUG
 g_timer_stop (timer);
 seconds = g_timer_elapsed (timer, NULL);
+#endif
 GST_INFO ("loaded %s in %lf seconds", location, seconds);
 res = TRUE;
-/* TODO: once we re-use the pointers to registry contents return here */
+/* TODO: once we re-use the pointers to registry contents, return here */
 Error:
+#ifndef GST_DISABLE_GST_DEBUG
 g_timer_destroy (timer);
+#endif
 if (mapped) {
 g_mapped_file_free (mapped);
 } else {
 g_free (contents);
 }

changeset 16	8e837d1bf446
parent 0	0e761a78d257
child 30	7e817e7e631c