Merge branch 'master' into 0.11
[platform/upstream/gstreamer.git] / gst / gstregistrybinary.c
1 /* GStreamer
2  * Copyright (C) 2006 Josep Torra <josep@fluendo.com>
3  *               2006 Mathieu Garcia <matthieu@fluendo.com>
4  *               2006,2007 Stefan Kost <ensonic@users.sf.net>
5  *               2008 Sebastian Dröge <slomo@circular-chaos.org>
6  *
7  * gstregistrybinary.c: GstRegistryBinary object, support routines
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Library General Public
11  * License as published by the Free Software Foundation; either
12  * version 2 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Library General Public License for more details.
18  *
19  * You should have received a copy of the GNU Library General Public
20  * License along with this library; if not, write to the
21  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
22  * Boston, MA 02111-1307, USA.
23  */
24
25 /* FIXME:
26  * - keep registry binary blob and reference strings
27  *   - don't free/unmmap contents when leaving gst_registry_binary_read_cache()
28  *     - free at gst_deinit() / _priv_gst_registry_cleanup() ?
29  *   - GstPlugin:
30  *     - GST_PLUGIN_FLAG_CONST
31  *   - GstPluginFeature, GstIndexFactory, GstElementFactory
32  *     - needs Flags (GST_PLUGIN_FEATURE_FLAG_CONST)
33  *     - can we turn loaded into flag?
34  * - why do we collect a list of binary chunks and not write immediately
35  *   - because we need to process subchunks, before we can set e.g. nr_of_items
36  *     in parent chunk
37  */
38
39 #ifdef HAVE_CONFIG_H
40 #  include "config.h"
41 #endif
42
43 #ifdef HAVE_UNISTD_H
44 #include <unistd.h>
45 #endif
46
47 #include <errno.h>
48 #include <stdio.h>
49
50 #if defined (_MSC_VER) && _MSC_VER >= 1400
51 #include <io.h>
52 #endif
53
54 #include <gst/gst_private.h>
55 #include <gst/gstconfig.h>
56 #include <gst/gstelement.h>
57 #include <gst/gsttypefind.h>
58 #include <gst/gsttypefindfactory.h>
59 #include <gst/gsturi.h>
60 #include <gst/gstinfo.h>
61 #include <gst/gstenumtypes.h>
62 #include <gst/gstpadtemplate.h>
63
64 #include <gst/gstregistrychunks.h>
65 #include <gst/gstregistrybinary.h>
66
67 #include <glib/gstdio.h>        /* for g_stat(), g_mapped_file(), ... */
68
69 #include "glib-compat-private.h"
70
71
72 #define GST_CAT_DEFAULT GST_CAT_REGISTRY
73
74 /* reading macros */
75 #define unpack_element(inptr, outptr, element, endptr, error_label) G_STMT_START{ \
76   if (inptr + sizeof(element) >= endptr) \
77     goto error_label; \
78   outptr = (element *) inptr; \
79   inptr += sizeof (element); \
80 }G_STMT_END
81
82 #define ALIGNMENT            (sizeof (void *))
83 #define alignment(_address)  (gsize)_address%ALIGNMENT
84 #define align(_ptr)          _ptr += (( alignment(_ptr) == 0) ? 0 : ALIGNMENT-alignment(_ptr))
85
86 /* Registry saving */
87
88 #ifdef G_OS_WIN32
89 /* On win32, we can't use g_mkstmp(), because of cross-DLL file I/O problems.
90  * So, we just create the entire binary registry in memory, then write it out
91  * with g_file_set_contents(), which creates a temporary file internally
92  */
93
94 typedef struct BinaryRegistryCache
95 {
96   const char *location;
97   guint8 *mem;
98   gssize len;
99 } BinaryRegistryCache;
100
101 static BinaryRegistryCache *
102 gst_registry_binary_cache_init (GstRegistry * registry, const char *location)
103 {
104   BinaryRegistryCache *cache = g_slice_new0 (BinaryRegistryCache);
105   cache->location = location;
106   return cache;
107 }
108
109 static int
110 gst_registry_binary_cache_write (BinaryRegistryCache * cache,
111     unsigned long offset, const void *data, int length)
112 {
113   cache->len = MAX (offset + length, cache->len);
114   cache->mem = g_realloc (cache->mem, cache->len);
115
116   memcpy (cache->mem + offset, data, length);
117
118   return length;
119 }
120
121 static gboolean
122 gst_registry_binary_cache_finish (BinaryRegistryCache * cache, gboolean success)
123 {
124   gboolean ret = TRUE;
125   GError *error = NULL;
126   if (!g_file_set_contents (cache->location, (const gchar *) cache->mem,
127           cache->len, &error)) {
128     /* Probably the directory didn't exist; create it */
129     gchar *dir;
130     dir = g_path_get_dirname (cache->location);
131     g_mkdir_with_parents (dir, 0777);
132     g_free (dir);
133
134     g_error_free (error);
135     error = NULL;
136
137     if (!g_file_set_contents (cache->location, (const gchar *) cache->mem,
138             cache->len, &error)) {
139       /* Probably the directory didn't exist; create it */
140       gchar *dir;
141       dir = g_path_get_dirname (cache->location);
142       g_mkdir_with_parents (dir, 0777);
143       g_free (dir);
144
145       g_error_free (error);
146       error = NULL;
147
148       if (!g_file_set_contents (cache->location, (const gchar *) cache->mem,
149               cache->len, &error)) {
150         GST_ERROR ("Failed to write to cache file: %s", error->message);
151         g_error_free (error);
152         ret = FALSE;
153       }
154     }
155   }
156
157   g_free (cache->mem);
158   g_slice_free (BinaryRegistryCache, cache);
159   return ret;
160 }
161
162 #else
163 typedef struct BinaryRegistryCache
164 {
165   const char *location;
166   char *tmp_location;
167   unsigned long currentoffset;
168   int cache_fd;
169 } BinaryRegistryCache;
170
171 static BinaryRegistryCache *
172 gst_registry_binary_cache_init (GstRegistry * registry, const char *location)
173 {
174   BinaryRegistryCache *cache = g_slice_new0 (BinaryRegistryCache);
175
176   cache->location = location;
177   cache->tmp_location = g_strconcat (location, ".tmpXXXXXX", NULL);
178   cache->cache_fd = g_mkstemp (cache->tmp_location);
179   if (cache->cache_fd == -1) {
180     int ret;
181     GStatBuf statbuf;
182     gchar *dir;
183
184     /* oops, I bet the directory doesn't exist */
185     dir = g_path_get_dirname (location);
186     g_mkdir_with_parents (dir, 0777);
187
188     ret = g_stat (dir, &statbuf);
189     if (ret != -1 && (statbuf.st_mode & 0700) != 0700) {
190       g_chmod (dir, 0700);
191     }
192
193     g_free (dir);
194
195     /* the previous g_mkstemp call overwrote the XXXXXX placeholder ... */
196     g_free (cache->tmp_location);
197     cache->tmp_location = g_strconcat (location, ".tmpXXXXXX", NULL);
198     cache->cache_fd = g_mkstemp (cache->tmp_location);
199
200     if (cache->cache_fd == -1) {
201       GST_DEBUG ("g_mkstemp() failed: %s", g_strerror (errno));
202       g_free (cache->tmp_location);
203       g_slice_free (BinaryRegistryCache, cache);
204       return NULL;
205     }
206
207     ret = g_stat (cache->tmp_location, &statbuf);
208     if (ret != -1 && (statbuf.st_mode & 0600) != 0600) {
209       g_chmod (cache->tmp_location, 0600);
210     }
211   }
212
213   return cache;
214 }
215
216 static int
217 gst_registry_binary_cache_write (BinaryRegistryCache * cache,
218     unsigned long offset, const void *data, int length)
219 {
220   long written;
221   if (offset != cache->currentoffset) {
222     if (lseek (cache->cache_fd, offset, SEEK_SET) != 0) {
223       GST_ERROR ("Seeking to new offset failed");
224       return FALSE;
225     }
226     cache->currentoffset = offset;
227   }
228
229   written = write (cache->cache_fd, data, length);
230   if (written != length) {
231     GST_ERROR ("Failed to write to cache file");
232   }
233   cache->currentoffset += written;
234
235   return written;
236 }
237
238 static gboolean
239 gst_registry_binary_cache_finish (BinaryRegistryCache * cache, gboolean success)
240 {
241   /* only fsync if we're actually going to use and rename the file below */
242   if (success && fsync (cache->cache_fd) < 0)
243     goto fsync_failed;
244
245   if (close (cache->cache_fd) < 0)
246     goto close_failed;
247
248   if (success) {
249     /* Only do the rename if we wrote the entire file successfully */
250     if (g_rename (cache->tmp_location, cache->location) < 0) {
251       GST_ERROR ("g_rename() failed: %s", g_strerror (errno));
252       goto rename_failed;
253     }
254   }
255
256   g_free (cache->tmp_location);
257   g_slice_free (BinaryRegistryCache, cache);
258   GST_INFO ("Wrote binary registry cache");
259   return TRUE;
260
261 /* ERRORS */
262 fail_after_close:
263   {
264     g_unlink (cache->tmp_location);
265     g_free (cache->tmp_location);
266     g_slice_free (BinaryRegistryCache, cache);
267     return FALSE;
268   }
269 fsync_failed:
270   {
271     GST_ERROR ("fsync() failed: %s", g_strerror (errno));
272     goto fail_after_close;
273   }
274 close_failed:
275   {
276     GST_ERROR ("close() failed: %s", g_strerror (errno));
277     goto fail_after_close;
278   }
279 rename_failed:
280   {
281     GST_ERROR ("g_rename() failed: %s", g_strerror (errno));
282     goto fail_after_close;
283   }
284 }
285 #endif
286
287 /*
288  * gst_registry_binary_write_chunk:
289  *
290  * Write from a memory location to the registry cache file
291  *
292  * Returns: %TRUE for success
293  */
294 inline static gboolean
295 gst_registry_binary_write_chunk (BinaryRegistryCache * cache,
296     GstRegistryChunk * chunk, unsigned long *file_position)
297 {
298   gchar padder[ALIGNMENT] = { 0, };
299   int padsize = 0;
300
301   /* Padding to insert the struct that requiere word alignment */
302   if ((chunk->align) && (alignment (*file_position) != 0)) {
303     padsize = ALIGNMENT - alignment (*file_position);
304     if (gst_registry_binary_cache_write (cache, *file_position,
305             padder, padsize) != padsize) {
306       GST_ERROR ("Failed to write binary registry padder");
307       return FALSE;
308     }
309     *file_position += padsize;
310   }
311
312   if (gst_registry_binary_cache_write (cache, *file_position,
313           chunk->data, chunk->size) != chunk->size) {
314     GST_ERROR ("Failed to write binary registry element");
315     return FALSE;
316   }
317
318   *file_position += chunk->size;
319
320   return TRUE;
321 }
322
323
324 /*
325  * gst_registry_binary_initialize_magic:
326  *
327  * Initialize the GstBinaryRegistryMagic, setting both our magic number and
328  * gstreamer major/minor version
329  */
330 inline static gboolean
331 gst_registry_binary_initialize_magic (GstBinaryRegistryMagic * m)
332 {
333   memset (m, 0, sizeof (GstBinaryRegistryMagic));
334
335   if (!strncpy (m->magic, GST_MAGIC_BINARY_REGISTRY_STR,
336           GST_MAGIC_BINARY_REGISTRY_LEN)
337       || !strncpy (m->version, GST_MAGIC_BINARY_VERSION_STR,
338           GST_MAGIC_BINARY_VERSION_LEN)) {
339     GST_ERROR ("Failed to write magic to the registry magic structure");
340     return FALSE;
341   }
342
343   return TRUE;
344 }
345
346 /**
347  * gst_registry_binary_write_cache:
348  * @registry: a #GstRegistry
349  * @location: a filename
350  *
351  * Write the @registry to a cache to file at given @location.
352  *
353  * Returns: %TRUE on success.
354  */
355 gboolean
356 gst_registry_binary_write_cache (GstRegistry * registry, const char *location)
357 {
358   GList *walk;
359   GstBinaryRegistryMagic magic;
360   GList *to_write = NULL;
361   unsigned long file_position = 0;
362   BinaryRegistryCache *cache;
363
364   GST_INFO ("Building binary registry cache image");
365
366   g_return_val_if_fail (GST_IS_REGISTRY (registry), FALSE);
367
368   if (!gst_registry_binary_initialize_magic (&magic))
369     goto fail;
370
371   /* iterate trough the list of plugins and fit them into binary structures */
372   for (walk = registry->plugins; walk; walk = g_list_next (walk)) {
373     GstPlugin *plugin = GST_PLUGIN (walk->data);
374
375     if (!plugin->filename)
376       continue;
377
378     if (plugin->flags & GST_PLUGIN_FLAG_CACHED) {
379       GStatBuf statbuf;
380
381       if (g_stat (plugin->filename, &statbuf) < 0 ||
382           plugin->file_mtime != statbuf.st_mtime ||
383           plugin->file_size != statbuf.st_size)
384         continue;
385     }
386
387     if (!_priv_gst_registry_chunks_save_plugin (&to_write, registry, plugin)) {
388       GST_ERROR ("Can't write binary plugin information for \"%s\"",
389           plugin->filename);
390     }
391   }
392
393   _priv_gst_registry_chunks_save_global_header (&to_write, registry,
394       priv_gst_plugin_loading_get_whitelist_hash ());
395
396   GST_INFO ("Writing binary registry cache");
397
398   cache = gst_registry_binary_cache_init (registry, location);
399   if (!cache)
400     goto fail_free_list;
401
402   /* write magic */
403   if (gst_registry_binary_cache_write (cache, file_position,
404           &magic, sizeof (GstBinaryRegistryMagic)) !=
405       sizeof (GstBinaryRegistryMagic)) {
406     GST_ERROR ("Failed to write binary registry magic");
407     goto fail_free_list;
408   }
409   file_position += sizeof (GstBinaryRegistryMagic);
410
411   /* write out data chunks */
412   for (walk = to_write; walk; walk = g_list_next (walk)) {
413     GstRegistryChunk *cur = walk->data;
414     gboolean res;
415
416     res = gst_registry_binary_write_chunk (cache, cur, &file_position);
417
418     _priv_gst_registry_chunk_free (cur);
419     walk->data = NULL;
420     if (!res)
421       goto fail_free_list;
422   }
423   g_list_free (to_write);
424
425   if (!gst_registry_binary_cache_finish (cache, TRUE))
426     return FALSE;
427
428   return TRUE;
429
430   /* Errors */
431 fail_free_list:
432   {
433     for (walk = to_write; walk; walk = g_list_next (walk)) {
434       GstRegistryChunk *cur = walk->data;
435
436       if (cur)
437         _priv_gst_registry_chunk_free (cur);
438     }
439     g_list_free (to_write);
440
441     if (cache)
442       (void) gst_registry_binary_cache_finish (cache, FALSE);
443     /* fall through */
444   }
445 fail:
446   {
447     return FALSE;
448   }
449 }
450
451
452 /* Registry loading */
453
454 /*
455  * gst_registry_binary_check_magic:
456  *
457  * Check GstBinaryRegistryMagic validity.
458  * Return < 0 if something is wrong, -2 means
459  * that just the version of the registry is out of
460  * date, -1 is a general failure.
461  */
462 static gint
463 gst_registry_binary_check_magic (gchar ** in, gsize size)
464 {
465   GstBinaryRegistryMagic *m;
466
467   align (*in);
468   GST_DEBUG ("Reading/casting for GstBinaryRegistryMagic at address %p", *in);
469   unpack_element (*in, m, GstBinaryRegistryMagic, (*in + size), fail);
470
471   if (strncmp (m->magic, GST_MAGIC_BINARY_REGISTRY_STR,
472           GST_MAGIC_BINARY_REGISTRY_LEN) != 0) {
473     GST_WARNING
474         ("Binary registry magic is different : %02x%02x%02x%02x != %02x%02x%02x%02x",
475         GST_MAGIC_BINARY_REGISTRY_STR[0] & 0xff,
476         GST_MAGIC_BINARY_REGISTRY_STR[1] & 0xff,
477         GST_MAGIC_BINARY_REGISTRY_STR[2] & 0xff,
478         GST_MAGIC_BINARY_REGISTRY_STR[3] & 0xff, m->magic[0] & 0xff,
479         m->magic[1] & 0xff, m->magic[2] & 0xff, m->magic[3] & 0xff);
480     return -1;
481   }
482   if (strncmp (m->version, GST_MAGIC_BINARY_VERSION_STR,
483           GST_MAGIC_BINARY_VERSION_LEN)) {
484     GST_WARNING ("Binary registry magic version is different : %s != %s",
485         GST_MAGIC_BINARY_VERSION_STR, m->version);
486     return -2;
487   }
488
489   return 0;
490
491 fail:
492   GST_WARNING ("Not enough data for binary registry magic structure");
493   return -1;
494 }
495
496 /**
497  * gst_registry_binary_read_cache:
498  * @registry: a #GstRegistry
499  * @location: a filename
500  *
501  * Read the contents of the binary cache file at @location into @registry.
502  *
503  * Returns: %TRUE on success.
504  */
505 gboolean
506 gst_registry_binary_read_cache (GstRegistry * registry, const char *location)
507 {
508   GMappedFile *mapped = NULL;
509   gchar *contents = NULL;
510   gchar *in = NULL;
511   gsize size;
512   GError *err = NULL;
513   gboolean res = FALSE;
514   guint32 filter_env_hash = 0;
515   gint check_magic_result;
516 #ifndef GST_DISABLE_GST_DEBUG
517   GTimer *timer = NULL;
518   gdouble seconds;
519 #endif
520
521   /* make sure these types exist */
522   GST_TYPE_ELEMENT_FACTORY;
523   GST_TYPE_TYPE_FIND_FACTORY;
524   GST_TYPE_INDEX_FACTORY;
525
526 #ifndef GST_DISABLE_GST_DEBUG
527   timer = g_timer_new ();
528 #endif
529
530   mapped = g_mapped_file_new (location, FALSE, &err);
531   if (G_UNLIKELY (err != NULL)) {
532     GST_INFO ("Unable to mmap file %s : %s", location, err->message);
533     g_error_free (err);
534     err = NULL;
535   }
536
537   if (mapped == NULL) {
538     /* Error mmap-ing the cache, try a plain memory read */
539
540     g_file_get_contents (location, &contents, &size, &err);
541     if (err != NULL) {
542       GST_INFO ("Unable to read file %s : %s", location, err->message);
543 #ifndef GST_DISABLE_GST_DEBUG
544       g_timer_destroy (timer);
545 #endif
546       g_error_free (err);
547       return FALSE;
548     }
549   } else {
550     /* This can't fail if g_mapped_file_new() succeeded */
551     contents = g_mapped_file_get_contents (mapped);
552     size = g_mapped_file_get_length (mapped);
553   }
554
555   /* in is a cursor pointer, we initialize it with the begin of registry and is updated on each read */
556   in = contents;
557   GST_DEBUG ("File data at address %p", in);
558   if (G_UNLIKELY (size < sizeof (GstBinaryRegistryMagic))) {
559     GST_ERROR ("No or broken registry header for file at %s", location);
560     goto Error;
561   }
562
563   /* check if header is valid */
564   if (G_UNLIKELY ((check_magic_result =
565               gst_registry_binary_check_magic (&in, size)) < 0)) {
566
567     if (check_magic_result == -1)
568       GST_ERROR
569           ("Binary registry type not recognized (invalid magic) for file at %s",
570           location);
571     goto Error;
572   }
573
574   if (!_priv_gst_registry_chunks_load_global_header (registry, &in,
575           contents + size, &filter_env_hash)) {
576     GST_ERROR ("Couldn't read global header chunk");
577     goto Error;
578   }
579
580   if (filter_env_hash != priv_gst_plugin_loading_get_whitelist_hash ()) {
581     GST_INFO_OBJECT (registry, "Plugin loading filter environment changed, "
582         "ignoring plugin cache to force update with new filter environment");
583     goto done;
584   }
585
586   /* check if there are plugins in the file */
587   if (G_UNLIKELY (!(((gsize) in + sizeof (GstRegistryChunkPluginElement)) <
588               (gsize) contents + size))) {
589     GST_INFO ("No binary plugins structure to read");
590     /* empty file, this is not an error */
591   } else {
592     gchar *end = contents + size;
593     /* read as long as we still have space for a GstRegistryChunkPluginElement */
594     for (;
595         ((gsize) in + sizeof (GstRegistryChunkPluginElement)) <
596         (gsize) contents + size;) {
597       GST_DEBUG ("reading binary registry %" G_GSIZE_FORMAT "(%x)/%"
598           G_GSIZE_FORMAT, (gsize) in - (gsize) contents,
599           (guint) ((gsize) in - (gsize) contents), size);
600       if (!_priv_gst_registry_chunks_load_plugin (registry, &in, end, NULL)) {
601         GST_ERROR ("Problem while reading binary registry %s", location);
602         goto Error;
603       }
604     }
605   }
606
607 done:
608
609 #ifndef GST_DISABLE_GST_DEBUG
610   g_timer_stop (timer);
611   seconds = g_timer_elapsed (timer, NULL);
612 #endif
613
614   GST_INFO ("loaded %s in %lf seconds", location, seconds);
615
616   res = TRUE;
617   /* TODO: once we re-use the pointers to registry contents, return here */
618
619 Error:
620 #ifndef GST_DISABLE_GST_DEBUG
621   g_timer_destroy (timer);
622 #endif
623   if (mapped) {
624     g_mapped_file_unref (mapped);
625   } else {
626     g_free (contents);
627   }
628   return res;
629 }