diff -r 71e347f905f2 -r 4a7fac7dd34a gstreamer_core/gst/gstregistrybinary.c --- a/gstreamer_core/gst/gstregistrybinary.c Fri Mar 19 09:35:09 2010 +0200 +++ b/gstreamer_core/gst/gstregistrybinary.c Fri Apr 16 15:15:52 2010 +0300 @@ -2,6 +2,7 @@ * Copyright (C) 2006 Josep Torra * 2006 Mathieu Garcia * 2006,2007 Stefan Kost + * 2008 Sebastian Dröge * * gstregistrybinary.c: GstRegistryBinary object, support routines * @@ -22,22 +23,21 @@ */ /* 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 @@ -74,62 +74,263 @@ #define GST_CAT_DEFAULT GST_CAT_REGISTRY -/* macros */ +/* count string length, but return -1 if we hit the eof */ +static gint +_strnlen (const gchar * str, gint maxlen) +{ + gint len = 0; + + if (G_UNLIKELY (len == maxlen)) + return -1; -#define unpack_element(_inptr, _outptr, _element) \ - _outptr = (_element *)_inptr; \ - _inptr += sizeof (_element) + while (*str++ != '\0') { + len++; + if (G_UNLIKELY (len == maxlen)) + return -1; + } + return len; +} -#define unpack_const_string(_inptr, _outptr) \ - _outptr = g_intern_string ((const gchar *)_inptr); \ - _inptr += strlen(_outptr) + 1 +/* reading macros */ -#define unpack_string(_inptr, _outptr) \ - _outptr = g_strdup ((gchar *)_inptr); \ - _inptr += strlen(_outptr) + 1 +#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 -#if !GST_HAVE_UNALIGNED_ACCESS -# define alignment32(_address) (gsize)_address%4 -# define align32(_ptr) _ptr += (( alignment32(_ptr) == 0) ? 0 : 4-alignment32(_ptr)) -#else -# define alignment32(_address) 0 -# define align32(_ptr) do {} while(0) -#endif +#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 +typedef struct BinaryRegistryCache +{ + 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 + /* - * 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[] = { 0, 0, 0, 0 }; + gchar padder[ALIGNMENT] = { 0, }; int padsize = 0; /* Padding to insert the struct that requiere word alignment */ - if ((align) && (alignment32 (*file_position) != 0)) { - padsize = 4 - alignment32 (*file_position); - if (write (registry->cache_file, padder, padsize) != padsize) { + if ((align) && (alignment (*file_position) != 0)) { + padsize = ALIGNMENT - alignment (*file_position); + 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 (write (registry->cache_file, mem, size) != size) { + if (gst_registry_binary_cache_write (registry, cache, *file_position, + mem, size) != size) { GST_ERROR ("Failed to write binary registry element"); return FALSE; } - *file_position = *file_position + size; + + *file_position += size; + return TRUE; } @@ -143,12 +344,16 @@ 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; } @@ -165,6 +370,11 @@ { 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; @@ -231,7 +441,7 @@ 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; @@ -272,7 +482,7 @@ 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; @@ -285,7 +495,7 @@ 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; @@ -326,13 +536,8 @@ } else if (GST_IS_TYPE_FIND_FACTORY (feature)) { GstBinaryTypeFindFactory *tff; GstTypeFindFactory *factory = GST_TYPE_FIND_FACTORY (feature); - gchar *str; - /* 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)); + tff = g_malloc0 (sizeof (GstBinaryTypeFindFactory)); chk = gst_registry_binary_make_data (tff, sizeof (GstBinaryTypeFindFactory)); tff->nextensions = 0; @@ -346,24 +551,31 @@ } } /* save caps */ - gst_caps_do_simplify (copy); - str = gst_caps_to_string (copy); - gst_caps_unref (copy); - gst_registry_binary_save_string (list, str); - } -#ifndef GST_DISABLE_INDEX - else if (GST_IS_INDEX_FACTORY (feature)) { + if (factory->caps) { + GstCaps *copy = gst_caps_copy (factory->caps); + gchar *str; + + /* we copy the caps here so we can simplify them + * before saving. This is a lot faster when loading + * 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); - } -#endif - else { + } else { GST_WARNING ("unhandled feature type '%s'", type_name); } @@ -385,6 +597,38 @@ 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: @@ -401,13 +645,23 @@ 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); @@ -419,11 +673,19 @@ 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); @@ -448,7 +710,6 @@ return FALSE; } - /** * gst_registry_binary_write_cache: * @registry: a #GstRegistry @@ -466,47 +727,18 @@ gst_registry_binary_write_cache (GstRegistry * registry, const char *location) { GList *walk; - gchar *tmp_location; - GstBinaryRegistryMagic *magic; - GstBinaryChunk *magic_chunk; + GstBinaryRegistryMagic magic; 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 (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)) + 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); @@ -515,11 +747,9 @@ continue; if (plugin->flags & GST_PLUGIN_FLAG_CACHED) { - int ret; struct stat statbuf; - ret = g_stat (plugin->filename, &statbuf); - if ((ret = g_stat (plugin->filename, &statbuf)) < 0 || + if (g_stat (plugin->filename, &statbuf) < 0 || plugin->file_mtime != statbuf.st_mtime || plugin->file_size != statbuf.st_size) continue; @@ -530,66 +760,61 @@ 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)) { - if (!(cur->flags & GST_BINARY_REGISTRY_FLAG_CONST)) - g_free (cur->data); - g_free (cur); - g_list_free (to_write); - goto fail; + 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 (close (registry->cache_file) < 0) - goto close_failed; + if (!gst_registry_binary_cache_finish (registry, cache, TRUE)) + return FALSE; - 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: +fail_free_list: { - (void) close (registry->cache_file); + 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); + + if (cache) + (void) gst_registry_binary_cache_finish (registry, cache, FALSE); /* fall through */ } -fail_after_close: - { - g_remove (tmp_location); - g_free (tmp_location); - return FALSE; - } -close_failed: +fail: { - 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; + return FALSE; } } @@ -600,21 +825,19 @@ * 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 + * date, -1 is a general failure. */ -static gboolean -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 @@ -624,14 +847,20 @@ 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); - return FALSE; + GST_MAGIC_BINARY_VERSION_STR, m->version); + return -2; } - return TRUE; + + return 0; + +fail: + GST_WARNING ("Not enough data for binary registry magic structure"); + return -1; } @@ -643,27 +872,33 @@ * 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_string (*in, template->static_caps.string); + unpack_const_string (*in, template->name_template, end, fail); + 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; } @@ -676,99 +911,109 @@ */ 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)) { - GST_ERROR ("typename : '%s' is not a plgin feature", type_name); + if (G_UNLIKELY (!GST_IS_PLUGIN_FEATURE (feature))) { + 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.klass); - unpack_string (*in, factory->details.description); - unpack_string (*in, factory->details.author); + unpack_string (*in, factory->details.longname, end, fail); + unpack_string (*in, factory->details.klass, end, fail); + unpack_string (*in, factory->details.description, end, fail); + 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++) { - if (!gst_registry_binary_load_pad_template (factory, in)) { + for (i = 0; i < n; i++) { + 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) { - GST_DEBUG ("Reading %d UriTypes at address %p", ef->nuriprotocols, *in); + if (G_UNLIKELY ((n = ef->nuriprotocols))) { + 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); - for (i = 0; i < ef->nuriprotocols; i++) { - unpack_string (*in, str); + factory->uri_protocols = g_new0 (gchar *, n + 1); + for (i = 0; i < n; i++) { + unpack_string (*in, str, end, fail); factory->uri_protocols[i] = str; } } + /* load interfaces */ - GST_DEBUG ("Reading %d Interfaces at address %p", ef->ninterfaces, *in); - for (i = 0; i < ef->ninterfaces; i++) { - unpack_string (*in, str); - __gst_element_factory_add_interface (factory, str); - g_free (str); + if (G_UNLIKELY ((n = ef->ninterfaces))) { + GST_DEBUG ("Reading %d Interfaces at address %p", n, *in); + for (i = 0; i < n; i++) { + unpack_string (*in, str, end, fail); + __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); - factory->caps = gst_caps_from_string (str); + unpack_string (*in, str, end, fail); + factory->caps = (str && *str) ? gst_caps_from_string (str) : NULL; g_free (str); /* load extensions */ if (tff->nextensions) { @@ -776,23 +1021,23 @@ 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; } } - } -#ifndef GST_DISABLE_INDEX - else if (GST_IS_INDEX_FACTORY (feature)) { + } 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 { + GST_WARNING ("unhandled factory type : %s", G_OBJECT_TYPE_NAME (feature)); + goto fail; } -#endif feature->rank = pf->rank; @@ -807,14 +1052,76 @@ /* Errors */ fail: + GST_INFO ("Reading plugin feature failed"); g_free (type_name); - if (GST_IS_OBJECT (feature)) - gst_object_unref (feature); - else - g_object_unref (feature); + if (feature) { + if (GST_IS_OBJECT (feature)) + gst_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: @@ -824,25 +1131,17 @@ * 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; - - align32 (*in); - GST_LOG ("Reading/casting for GstBinaryPluginElement at address %p", *in); - unpack_element (*in, pe, GstBinaryPluginElement); + gchar *cache_str = NULL; + guint i, n; - 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; - } + align (*in); + GST_LOG ("Reading/casting for GstBinaryPluginElement at address %p", *in); + unpack_element (*in, pe, GstBinaryPluginElement, end, fail); plugin = g_object_new (GST_TYPE_PLUGIN, NULL); @@ -852,23 +1151,53 @@ plugin->file_size = pe->file_size; /* unpack plugin element strings */ - unpack_const_string (*in, plugin->desc.name); - unpack_string (*in, plugin->desc.description); - unpack_string (*in, plugin->filename); - unpack_const_string (*in, plugin->desc.version); - unpack_const_string (*in, plugin->desc.license); - unpack_const_string (*in, plugin->desc.source); - unpack_const_string (*in, plugin->desc.package); - unpack_const_string (*in, plugin->desc.origin); - GST_LOG ("read strings for '%s'", plugin->desc.name); + unpack_const_string (*in, plugin->desc.name, end, fail); + unpack_string (*in, plugin->desc.description, end, fail); + unpack_string (*in, plugin->filename, end, fail); + unpack_const_string (*in, plugin->desc.version, end, fail); + unpack_const_string (*in, plugin->desc.license, end, fail); + unpack_const_string (*in, plugin->desc.source, end, fail); + unpack_const_string (*in, plugin->desc.package, end, fail); + unpack_const_string (*in, plugin->desc.origin, end, fail); + 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", - plugin->desc.name, pe->nfeatures); - for (i = 0; i < pe->nfeatures; i++) { - if (!gst_registry_binary_load_feature (registry, in, plugin->desc.name)) { + n = pe->nfeatures; + GST_DEBUG ("Added plugin '%s' plugin with %d features from binary registry", + plugin->desc.name, n); + + /* 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; } } @@ -877,7 +1206,7 @@ /* Errors */ fail: - gst_object_unref (plugin); + GST_INFO ("Reading plugin failed"); return FALSE; } @@ -894,30 +1223,32 @@ #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; @@ -925,63 +1256,75 @@ 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)) { - GST_ERROR - ("Binary registry type not recognized (invalid magic) for file at %s", - location); + if (G_UNLIKELY ((check_magic_result = + gst_registry_binary_check_magic (&in, size)) < 0)) { + + 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 (!(((gsize) in + sizeof (GstBinaryPluginElement)) < - (gsize) contents + size)) { + if (G_UNLIKELY (!(((gsize) in + sizeof (GstBinaryPluginElement)) < + (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)) { - GST_ERROR ("Problem while reading binary registry"); + if (!gst_registry_binary_load_plugin (registry, &in, end)) { + 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 {