Merge branch 'master' into 0.11
[platform/upstream/gstreamer.git] / gst / gstpluginloader.c
1 /* GStreamer
2  * Copyright (C) 2008 Jan Schmidt <jan.schmidt@sun.com>
3  *
4  * gstpluginloader.c: GstPluginLoader helper for loading plugin files
5  * out of process.
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Library General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Library General Public License for more details.
16  *
17  * You should have received a copy of the GNU Library General Public
18  * License along with this library; if not, write to the
19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20  * Boston, MA 02111-1307, USA.
21  */
22
23 #ifdef HAVE_CONFIG_H
24 #  include "config.h"
25 #endif
26
27 #include <gst/gst_private.h>
28
29 #ifndef G_OS_WIN32
30 #include <sys/types.h>
31 #include <sys/wait.h>
32 #include <sys/stat.h>
33 #include <fcntl.h>
34 #include <unistd.h>
35 #else
36 #define fsync(fd) _commit(fd)
37 #include <io.h>
38 #endif
39
40 #ifdef HAVE_SYS_UTSNAME_H
41 #include <sys/utsname.h>
42 #endif
43
44 #include <errno.h>
45
46 #include <gst/gstconfig.h>
47
48 #include <gst/gstpoll.h>
49 #include <gst/gstutils.h>
50
51 #include <gst/gstpluginloader.h>
52 #include <gst/gstregistrychunks.h>
53 #include <gst/gstregistrybinary.h>
54
55 /* IMPORTANT: Bump the version number if the plugin loader packet protocol
56  * changes. Changes in the binary registry format itself are handled by
57  * bumping the GST_MAGIC_BINARY_VERSION_STR
58  */
59 static const guint32 loader_protocol_version = 3;
60
61 #define GST_CAT_DEFAULT GST_CAT_PLUGIN_LOADING
62
63 static GstPluginLoader *plugin_loader_new (GstRegistry * registry);
64 static gboolean plugin_loader_free (GstPluginLoader * loader);
65 static gboolean plugin_loader_load (GstPluginLoader * loader,
66     const gchar * filename, off_t file_size, time_t file_mtime);
67
68 /* functions used in GstRegistry scanning */
69 const GstPluginLoaderFuncs _priv_gst_plugin_loader_funcs = {
70   plugin_loader_new, plugin_loader_free, plugin_loader_load
71 };
72
73 typedef struct _PendingPluginEntry
74 {
75   /* sequence number */
76   guint32 tag;
77   gchar *filename;
78   off_t file_size;
79   time_t file_mtime;
80 } PendingPluginEntry;
81
82 struct _GstPluginLoader
83 {
84   GstRegistry *registry;
85   GstPoll *fdset;
86
87   gboolean child_running;
88   GPid child_pid;
89   GstPollFD fd_w;
90   GstPollFD fd_r;
91
92   gboolean is_child;
93   gboolean got_plugin_details;
94
95   /* Transmit buffer */
96   guint8 *tx_buf;
97   guint tx_buf_size;
98   guint tx_buf_write;
99   guint tx_buf_read;
100
101   /* next sequence number (for PendingPluginEntry) */
102   guint32 next_tag;
103
104   guint8 *rx_buf;
105   guint rx_buf_size;
106   gboolean rx_done;
107   gboolean rx_got_sync;
108
109   /* Head and tail of the pending plugins list. List of
110      PendingPluginEntry structs */
111   GList *pending_plugins;
112   GList *pending_plugins_tail;
113 };
114
115 #define PACKET_EXIT 1
116 #define PACKET_LOAD_PLUGIN 2
117 #define PACKET_SYNC 3
118 #define PACKET_PLUGIN_DETAILS 4
119 #define PACKET_VERSION 5
120
121 #define BUF_INIT_SIZE 512
122 #define BUF_GROW_EXTRA 512
123 #define BUF_MAX_SIZE (32 * 1024 * 1024)
124
125 #define HEADER_SIZE 12
126 /* 4 magic hex bytes to mark each packet */
127 #define HEADER_MAGIC 0xbefec0ae
128 #define ALIGNMENT   (sizeof (void *))
129
130 static gboolean gst_plugin_loader_spawn (GstPluginLoader * loader);
131 static void put_packet (GstPluginLoader * loader, guint type, guint32 tag,
132     const guint8 * payload, guint32 payload_len);
133 static gboolean exchange_packets (GstPluginLoader * l);
134 static gboolean plugin_loader_replay_pending (GstPluginLoader * l);
135 static gboolean plugin_loader_load_and_sync (GstPluginLoader * l,
136     PendingPluginEntry * entry);
137 static void plugin_loader_create_blacklist_plugin (GstPluginLoader * l,
138     PendingPluginEntry * entry);
139 static void plugin_loader_cleanup_child (GstPluginLoader * loader);
140 static gboolean plugin_loader_sync_with_child (GstPluginLoader * l);
141
142 static GstPluginLoader *
143 plugin_loader_new (GstRegistry * registry)
144 {
145   GstPluginLoader *l = g_slice_new0 (GstPluginLoader);
146
147   if (registry)
148     l->registry = gst_object_ref (registry);
149   l->fdset = gst_poll_new (FALSE);
150   gst_poll_fd_init (&l->fd_w);
151   gst_poll_fd_init (&l->fd_r);
152
153   l->tx_buf_size = BUF_INIT_SIZE;
154   l->tx_buf = g_malloc (BUF_INIT_SIZE);
155
156   l->next_tag = 0;
157
158   l->rx_buf_size = BUF_INIT_SIZE;
159   l->rx_buf = g_malloc (BUF_INIT_SIZE);
160
161   return l;
162 }
163
164 static gboolean
165 plugin_loader_free (GstPluginLoader * loader)
166 {
167   GList *cur;
168   gboolean got_plugin_details;
169
170   fsync (loader->fd_w.fd);
171
172   if (loader->child_running) {
173     put_packet (loader, PACKET_EXIT, 0, NULL, 0);
174
175     /* Swap packets with the child until it exits cleanly */
176     while (!loader->rx_done) {
177       if (exchange_packets (loader) || loader->rx_done)
178         continue;
179
180       if (!plugin_loader_replay_pending (loader))
181         break;
182       put_packet (loader, PACKET_EXIT, 0, NULL, 0);
183     }
184
185     plugin_loader_cleanup_child (loader);
186   } else {
187     close (loader->fd_w.fd);
188     close (loader->fd_r.fd);
189   }
190
191   gst_poll_free (loader->fdset);
192
193   g_free (loader->rx_buf);
194   g_free (loader->tx_buf);
195
196   if (loader->registry)
197     gst_object_unref (loader->registry);
198
199   got_plugin_details = loader->got_plugin_details;
200
201   /* Free any pending plugin entries */
202   cur = loader->pending_plugins;
203   while (cur) {
204     PendingPluginEntry *entry = (PendingPluginEntry *) (cur->data);
205     g_free (entry->filename);
206     g_slice_free (PendingPluginEntry, entry);
207
208     cur = g_list_delete_link (cur, cur);
209   }
210
211   g_slice_free (GstPluginLoader, loader);
212
213   return got_plugin_details;
214 }
215
216 static gboolean
217 plugin_loader_load (GstPluginLoader * loader, const gchar * filename,
218     off_t file_size, time_t file_mtime)
219 {
220   gint len;
221   PendingPluginEntry *entry;
222
223   if (!gst_plugin_loader_spawn (loader))
224     return FALSE;
225
226   /* Send a packet to the child requesting that it load the given file */
227   GST_LOG_OBJECT (loader->registry,
228       "Sending file %s to child. tag %u", filename, loader->next_tag);
229
230   entry = g_slice_new (PendingPluginEntry);
231   entry->tag = loader->next_tag++;
232   entry->filename = g_strdup (filename);
233   entry->file_size = file_size;
234   entry->file_mtime = file_mtime;
235   loader->pending_plugins_tail =
236       g_list_append (loader->pending_plugins_tail, entry);
237
238   if (loader->pending_plugins == NULL)
239     loader->pending_plugins = loader->pending_plugins_tail;
240   else
241     loader->pending_plugins_tail = g_list_next (loader->pending_plugins_tail);
242
243   len = strlen (filename);
244   put_packet (loader, PACKET_LOAD_PLUGIN, entry->tag,
245       (guint8 *) filename, len + 1);
246
247   if (!exchange_packets (loader)) {
248     if (!plugin_loader_replay_pending (loader))
249       return FALSE;
250   }
251
252   return TRUE;
253 }
254
255 static gboolean
256 plugin_loader_replay_pending (GstPluginLoader * l)
257 {
258   GList *cur, *next;
259
260 restart:
261   if (!gst_plugin_loader_spawn (l))
262     return FALSE;
263
264   /* Load each plugin one by one synchronously until we find the
265    * crashing one */
266   while ((cur = l->pending_plugins)) {
267     PendingPluginEntry *entry = (PendingPluginEntry *) (cur->data);
268
269     if (!plugin_loader_load_and_sync (l, entry)) {
270       /* Create dummy plugin entry to block re-scanning this file */
271       GST_ERROR ("Plugin file %s failed to load. Blacklisting",
272           entry->filename);
273       plugin_loader_create_blacklist_plugin (l, entry);
274       l->got_plugin_details = TRUE;
275       /* Now remove this crashy plugin from the head of the list */
276       l->pending_plugins = g_list_delete_link (cur, cur);
277       g_free (entry->filename);
278       g_slice_free (PendingPluginEntry, entry);
279       if (l->pending_plugins == NULL)
280         l->pending_plugins_tail = NULL;
281       if (!gst_plugin_loader_spawn (l))
282         return FALSE;
283       break;
284     }
285   }
286
287   /* We exited after finding the crashing one. If there's any more pending,
288    * dispatch them post-haste, but don't wait */
289   for (cur = l->pending_plugins; cur != NULL; cur = next) {
290     PendingPluginEntry *entry = (PendingPluginEntry *) (cur->data);
291
292     next = g_list_next (cur);
293
294     put_packet (l, PACKET_LOAD_PLUGIN, entry->tag,
295         (guint8 *) entry->filename, strlen (entry->filename) + 1);
296
297     /* This might invalidate cur, which is why we grabbed 'next' above */
298     if (!exchange_packets (l))
299       goto restart;
300   }
301
302   return TRUE;
303 }
304
305 static gboolean
306 plugin_loader_sync_with_child (GstPluginLoader * l)
307 {
308   put_packet (l, PACKET_SYNC, 0, NULL, 0);
309
310   l->rx_got_sync = FALSE;
311   while (!l->rx_got_sync) {
312     if (!exchange_packets (l))
313       return FALSE;
314   }
315   return TRUE;
316 }
317
318 static gboolean
319 plugin_loader_load_and_sync (GstPluginLoader * l, PendingPluginEntry * entry)
320 {
321   gint len;
322
323   GST_DEBUG_OBJECT (l->registry, "Synchronously loading plugin file %s",
324       entry->filename);
325
326   len = strlen (entry->filename);
327   put_packet (l, PACKET_LOAD_PLUGIN, entry->tag,
328       (guint8 *) entry->filename, len + 1);
329
330   return plugin_loader_sync_with_child (l);
331 }
332
333 static void
334 plugin_loader_create_blacklist_plugin (GstPluginLoader * l,
335     PendingPluginEntry * entry)
336 {
337   GstPlugin *plugin = g_object_newv (GST_TYPE_PLUGIN, 0, NULL);
338
339   plugin->filename = g_strdup (entry->filename);
340   plugin->file_mtime = entry->file_mtime;
341   plugin->file_size = entry->file_size;
342   plugin->flags |= GST_PLUGIN_FLAG_BLACKLISTED;
343
344   plugin->basename = g_path_get_basename (plugin->filename);
345   plugin->desc.name = g_intern_string (plugin->basename);
346   plugin->desc.description = "Plugin for blacklisted file";
347   plugin->desc.version = "0.0.0";
348   plugin->desc.license = "BLACKLIST";
349   plugin->desc.source = plugin->desc.license;
350   plugin->desc.package = plugin->desc.license;
351   plugin->desc.origin = plugin->desc.license;
352
353   GST_DEBUG ("Adding blacklist plugin '%s'", plugin->desc.name);
354   gst_registry_add_plugin (l->registry, plugin);
355 }
356
357 #ifdef __APPLE__
358 #if defined(__x86_64__)
359 #define USR_BIN_ARCH_SWITCH "-x86_64"
360 #elif defined(__i386__)
361 #define USR_BIN_ARCH_SWITCH "-i386"
362 #elif defined(__ppc__)
363 #define USR_BIN_ARCH_SWITCH "-ppc"
364 #elif defined(__ppc64__)
365 #define USR_BIN_ARCH_SWITCH "-ppc64"
366 #endif
367 #endif
368
369 #define YES_MULTIARCH 1
370 #define NO_MULTIARCH  2
371
372 #if defined (__APPLE__) && defined (USR_BIN_ARCH_SWITCH)
373 static gboolean
374 gst_plugin_loader_use_usr_bin_arch (void)
375 {
376   static volatile gsize multiarch = 0;
377
378   if (g_once_init_enter (&multiarch)) {
379     gsize res = NO_MULTIARCH;
380
381 #ifdef HAVE_SYS_UTSNAME_H
382     {
383       struct utsname uname_data;
384
385       if (uname (&uname_data) == 0) {
386         /* Check for OS X >= 10.5 (darwin kernel 9.0) */
387         GST_LOG ("%s %s", uname_data.sysname, uname_data.release);
388         if (g_ascii_strcasecmp (uname_data.sysname, "Darwin") == 0 &&
389             g_strtod (uname_data.release, NULL) >= 9.0) {
390           res = YES_MULTIARCH;
391         }
392       }
393     }
394 #endif
395
396     GST_INFO ("multiarch: %s", (res == YES_MULTIARCH) ? "yes" : "no");
397     g_once_init_leave (&multiarch, res);
398   }
399   return (multiarch == YES_MULTIARCH);
400 }
401 #endif /* __APPLE__ && USR_BIN_ARCH_SWITCH */
402
403 static gboolean
404 gst_plugin_loader_try_helper (GstPluginLoader * loader, gchar * location)
405 {
406   char *argv[5] = { NULL, };
407   int c = 0;
408
409 #if defined (__APPLE__) && defined (USR_BIN_ARCH_SWITCH)
410   if (gst_plugin_loader_use_usr_bin_arch ()) {
411     argv[c++] = (char *) "/usr/bin/arch";
412     argv[c++] = (char *) USR_BIN_ARCH_SWITCH;
413   }
414 #endif
415   argv[c++] = location;
416   argv[c++] = (char *) "-l";
417   argv[c++] = NULL;
418
419   if (c > 3) {
420     GST_LOG ("Trying to spawn gst-plugin-scanner helper at %s with arch %s",
421         location, argv[1]);
422   } else {
423     GST_LOG ("Trying to spawn gst-plugin-scanner helper at %s", location);
424   }
425
426   if (!g_spawn_async_with_pipes (NULL, argv, NULL,
427           G_SPAWN_DO_NOT_REAP_CHILD /* | G_SPAWN_STDERR_TO_DEV_NULL */ ,
428           NULL, NULL, &loader->child_pid, &loader->fd_w.fd, &loader->fd_r.fd,
429           NULL, NULL))
430     return FALSE;
431
432   gst_poll_add_fd (loader->fdset, &loader->fd_w);
433   gst_poll_add_fd (loader->fdset, &loader->fd_r);
434
435   gst_poll_fd_ctl_read (loader->fdset, &loader->fd_r, TRUE);
436
437   loader->tx_buf_write = loader->tx_buf_read = 0;
438
439   put_packet (loader, PACKET_VERSION, 0, NULL, 0);
440   if (!plugin_loader_sync_with_child (loader))
441     return FALSE;
442
443   loader->child_running = TRUE;
444
445   return TRUE;
446 }
447
448 static gboolean
449 gst_plugin_loader_spawn (GstPluginLoader * loader)
450 {
451   const gchar *env;
452   char *helper_bin;
453   gboolean res = FALSE;
454
455   if (loader->child_running)
456     return TRUE;
457
458   /* Find the gst-plugin-scanner: first try the env-var if it is set,
459    * otherwise use the installed version */
460   env = g_getenv ("GST_PLUGIN_SCANNER");
461
462   if (env != NULL && *env != '\0') {
463     GST_LOG ("Trying GST_PLUGIN_SCANNER env var: %s", env);
464     helper_bin = g_strdup (env);
465     res = gst_plugin_loader_try_helper (loader, helper_bin);
466     g_free (helper_bin);
467   }
468
469   if (!res) {
470     GST_LOG ("Trying installed plugin scanner");
471     helper_bin = g_strdup (GST_PLUGIN_SCANNER_INSTALLED);
472     res = gst_plugin_loader_try_helper (loader, helper_bin);
473     g_free (helper_bin);
474
475     if (!res) {
476       GST_INFO ("No gst-plugin-scanner available, or not working");
477     }
478   }
479
480   return loader->child_running;
481 }
482
483 static void
484 plugin_loader_cleanup_child (GstPluginLoader * l)
485 {
486   if (!l->child_running || l->is_child)
487     return;
488
489   gst_poll_remove_fd (l->fdset, &l->fd_w);
490   gst_poll_remove_fd (l->fdset, &l->fd_r);
491
492   close (l->fd_w.fd);
493   close (l->fd_r.fd);
494
495 #ifndef G_OS_WIN32
496   GST_LOG ("waiting for child process to exit");
497   waitpid (l->child_pid, NULL, 0);
498 #else
499   g_warning ("FIXME: Implement child process shutdown for Win32");
500 #endif
501   g_spawn_close_pid (l->child_pid);
502
503   l->child_running = FALSE;
504 }
505
506 gboolean
507 _gst_plugin_loader_client_run (void)
508 {
509   GstPluginLoader *l;
510
511   l = plugin_loader_new (NULL);
512   if (l == NULL)
513     return FALSE;
514
515   /* On entry, the inward pipe is STDIN, and outward is STDOUT.
516    * Dup those somewhere better so that plugins printing things
517    * won't interfere with anything */
518 #ifndef G_OS_WIN32
519   {
520     int dup_fd;
521
522     dup_fd = dup (0);           /* STDIN */
523     if (dup_fd == -1) {
524       GST_ERROR ("Failed to start. Could no dup STDIN, errno %d", errno);
525       return FALSE;
526     }
527     l->fd_r.fd = dup_fd;
528     close (0);
529
530     dup_fd = dup (1);           /* STDOUT */
531     if (dup_fd == -1) {
532       GST_ERROR ("Failed to start. Could no dup STDOUT, errno %d", errno);
533       return FALSE;
534     }
535     l->fd_w.fd = dup_fd;
536     close (1);
537
538     /* Dup stderr down to stdout so things that plugins print are visible,
539      * but don't care if it fails */
540     dup2 (2, 1);
541   }
542 #else
543   /* FIXME: Use DuplicateHandle and friends on win32 */
544   l->fd_w.fd = 1;               /* STDOUT */
545   l->fd_r.fd = 0;               /* STDIN */
546 #endif
547
548   gst_poll_add_fd (l->fdset, &l->fd_w);
549   gst_poll_add_fd (l->fdset, &l->fd_r);
550   gst_poll_fd_ctl_read (l->fdset, &l->fd_r, TRUE);
551
552   l->is_child = TRUE;
553
554   GST_DEBUG ("Plugin scanner child running. Waiting for instructions");
555
556   /* Loop, listening for incoming packets on the fd and writing responses */
557   while (!l->rx_done && exchange_packets (l));
558
559   plugin_loader_free (l);
560
561   return TRUE;
562 }
563
564 static void
565 put_packet (GstPluginLoader * l, guint type, guint32 tag,
566     const guint8 * payload, guint32 payload_len)
567 {
568   guint8 *out;
569   guint len = payload_len + HEADER_SIZE;
570
571   if (l->tx_buf_write + len >= l->tx_buf_size) {
572     GST_LOG ("Expanding tx buf from %d to %d for packet of size %d",
573         l->tx_buf_size, l->tx_buf_write + len + BUF_GROW_EXTRA, len);
574     l->tx_buf_size = l->tx_buf_write + len + BUF_GROW_EXTRA;
575     l->tx_buf = g_realloc (l->tx_buf, l->tx_buf_size);
576   }
577
578   out = l->tx_buf + l->tx_buf_write;
579
580   /* one byte packet type */
581   out[0] = type;
582   /* 3 byte packet tag number */
583   GST_WRITE_UINT24_BE (out + 1, tag);
584   /* 4 bytes packet length */
585   GST_WRITE_UINT32_BE (out + 4, payload_len);
586   /* payload */
587   memcpy (out + HEADER_SIZE, payload, payload_len);
588   /* Write magic into the header */
589   GST_WRITE_UINT32_BE (out + 8, HEADER_MAGIC);
590
591   l->tx_buf_write += len;
592   gst_poll_fd_ctl_write (l->fdset, &l->fd_w, TRUE);
593 }
594
595 static void
596 put_chunk (GstPluginLoader * l, GstRegistryChunk * chunk, guint * pos)
597 {
598   guint padsize = 0;
599   guint len;
600   guint8 *out;
601
602   /* Might need to align the chunk */
603   if (chunk->align && ((*pos) % ALIGNMENT) != 0)
604     padsize = ALIGNMENT - ((*pos) % ALIGNMENT);
605
606   len = padsize + chunk->size;
607
608   if (G_UNLIKELY (l->tx_buf_write + len >= l->tx_buf_size)) {
609     guint new_size = MAX (l->tx_buf_write + len,
610         l->tx_buf_size + l->tx_buf_size / 4) + BUF_GROW_EXTRA;
611     GST_LOG ("Expanding tx buf from %d to %d for chunk of size %d",
612         l->tx_buf_size, new_size, chunk->size);
613     l->tx_buf_size = new_size;
614     l->tx_buf = g_realloc (l->tx_buf, l->tx_buf_size);
615   }
616
617   out = l->tx_buf + l->tx_buf_write;
618   /* Clear the padding */
619   if (padsize)
620     memset (out, 0, padsize);
621   memcpy (out + padsize, chunk->data, chunk->size);
622
623   l->tx_buf_write += len;
624   *pos += len;
625
626   gst_poll_fd_ctl_write (l->fdset, &l->fd_w, TRUE);
627 };
628
629 static gboolean
630 write_one (GstPluginLoader * l)
631 {
632   guint8 *out;
633   guint32 to_write, magic;
634   int res;
635
636   if (l->tx_buf_read + HEADER_SIZE > l->tx_buf_write)
637     return FALSE;
638
639   out = l->tx_buf + l->tx_buf_read;
640
641   magic = GST_READ_UINT32_BE (out + 8);
642   if (magic != HEADER_MAGIC) {
643     GST_ERROR ("Packet magic number is missing. Memory corruption detected");
644     goto fail_and_cleanup;
645   }
646
647   to_write = GST_READ_UINT32_BE (out + 4) + HEADER_SIZE;
648   /* Check that the magic is intact, and the size is sensible */
649   if (to_write > l->tx_buf_size) {
650     GST_ERROR ("Indicated packet size is too large. Corruption detected");
651     goto fail_and_cleanup;
652   }
653
654   l->tx_buf_read += to_write;
655
656   GST_LOG ("Writing packet of size %d bytes to fd %d", to_write, l->fd_w.fd);
657
658   do {
659     res = write (l->fd_w.fd, out, to_write);
660     if (G_UNLIKELY (res < 0)) {
661       if (errno == EAGAIN || errno == EINTR)
662         continue;
663       /* Failed to write -> child died */
664       goto fail_and_cleanup;
665     }
666     to_write -= res;
667     out += res;
668   } while (to_write > 0);
669
670   if (l->tx_buf_read == l->tx_buf_write) {
671     gst_poll_fd_ctl_write (l->fdset, &l->fd_w, FALSE);
672     l->tx_buf_read = l->tx_buf_write = 0;
673   }
674
675   return TRUE;
676
677 fail_and_cleanup:
678   plugin_loader_cleanup_child (l);
679   return FALSE;
680 }
681
682 static gboolean
683 do_plugin_load (GstPluginLoader * l, const gchar * filename, guint tag)
684 {
685   GstPlugin *newplugin;
686   GList *chunks = NULL;
687
688   GST_DEBUG ("Plugin scanner loading file %s. tag %u", filename, tag);
689
690 #if 0                           /* Test code - crash based on filename */
691   if (strstr (filename, "coreelements") == NULL) {
692     g_printerr ("Crashing on file %s\n", filename);
693     g_printerr ("%d", *(gint *) (NULL));
694   }
695 #endif
696
697   newplugin = gst_plugin_load_file ((gchar *) filename, NULL);
698   if (newplugin) {
699     guint hdr_pos;
700     guint offset;
701
702     /* Now serialise the plugin details and send */
703     if (!_priv_gst_registry_chunks_save_plugin (&chunks,
704             gst_registry_get_default (), newplugin))
705       goto fail;
706
707     /* Store where the header is, write an empty one, then write
708      * all the payload chunks, then fix up the header size */
709     hdr_pos = l->tx_buf_write;
710     offset = HEADER_SIZE;
711     put_packet (l, PACKET_PLUGIN_DETAILS, tag, NULL, 0);
712
713     if (chunks) {
714       GList *walk;
715       for (walk = chunks; walk; walk = g_list_next (walk)) {
716         GstRegistryChunk *cur = walk->data;
717         put_chunk (l, cur, &offset);
718
719         _priv_gst_registry_chunk_free (cur);
720       }
721
722       g_list_free (chunks);
723
724       /* Store the size of the written payload */
725       GST_WRITE_UINT32_BE (l->tx_buf + hdr_pos + 4, offset - HEADER_SIZE);
726     }
727 #if 0                           /* Test code - corrupt the tx buffer based on filename */
728     if (strstr (filename, "sink") != NULL) {
729       int fd, res;
730       g_printerr ("Corrupting tx buf on file %s\n", filename);
731       fd = open ("/dev/urandom", O_RDONLY);
732       res = read (fd, l->tx_buf, l->tx_buf_size);
733       close (fd);
734     }
735 #endif
736
737     gst_object_unref (newplugin);
738   } else {
739     put_packet (l, PACKET_PLUGIN_DETAILS, tag, NULL, 0);
740   }
741
742   return TRUE;
743 fail:
744   put_packet (l, PACKET_PLUGIN_DETAILS, tag, NULL, 0);
745   if (chunks) {
746     GList *walk;
747     for (walk = chunks; walk; walk = g_list_next (walk)) {
748       GstRegistryChunk *cur = walk->data;
749
750       _priv_gst_registry_chunk_free (cur);
751     }
752
753     g_list_free (chunks);
754   }
755
756   return FALSE;
757 }
758
759 static gboolean
760 check_protocol_version (GstPluginLoader * l, guint8 * payload,
761     guint payload_len)
762 {
763   guint32 got_version;
764   guint8 *binary_reg_ver;
765
766   if (payload_len < sizeof (guint32) + GST_MAGIC_BINARY_VERSION_LEN)
767     return FALSE;
768
769   got_version = GST_READ_UINT32_BE (payload);
770   GST_LOG ("Got VERSION %u from child. Ours is %u", got_version,
771       loader_protocol_version);
772   if (got_version != loader_protocol_version)
773     return FALSE;
774
775   binary_reg_ver = payload + sizeof (guint32);
776   if (strcmp ((gchar *) binary_reg_ver, GST_MAGIC_BINARY_VERSION_STR)) {
777     GST_LOG ("Binary chunk format of child is different. Ours: %s, child %s\n",
778         GST_MAGIC_BINARY_VERSION_STR, binary_reg_ver);
779     return FALSE;
780   }
781
782   return TRUE;
783 };
784
785 static gboolean
786 handle_rx_packet (GstPluginLoader * l,
787     guint pack_type, guint32 tag, guint8 * payload, guint payload_len)
788 {
789   gboolean res = TRUE;
790
791   switch (pack_type) {
792     case PACKET_EXIT:
793       gst_poll_fd_ctl_read (l->fdset, &l->fd_r, FALSE);
794       if (l->is_child) {
795         /* Respond */
796         put_packet (l, PACKET_EXIT, 0, NULL, 0);
797       }
798       l->rx_done = TRUE;
799       return TRUE;
800     case PACKET_LOAD_PLUGIN:{
801       if (!l->is_child)
802         return TRUE;
803
804       /* Payload is the filename to load */
805       res = do_plugin_load (l, (gchar *) payload, tag);
806
807       break;
808     }
809     case PACKET_PLUGIN_DETAILS:{
810       gchar *tmp = (gchar *) payload;
811       PendingPluginEntry *entry = NULL;
812       GList *cur;
813
814       GST_DEBUG_OBJECT (l->registry,
815           "Received plugin details from child w/ tag %u. %d bytes info",
816           tag, payload_len);
817
818       /* Assume that tagged details come back in the order
819        * we requested, and delete anything before (but not
820        * including) this one */
821       cur = l->pending_plugins;
822       while (cur) {
823         PendingPluginEntry *e = (PendingPluginEntry *) (cur->data);
824
825         if (e->tag > tag)
826           break;
827
828         if (e->tag == tag) {
829           entry = e;
830           break;
831         } else {
832           cur = g_list_delete_link (cur, cur);
833           g_free (e->filename);
834           g_slice_free (PendingPluginEntry, e);
835         }
836       }
837
838       l->pending_plugins = cur;
839       if (cur == NULL)
840         l->pending_plugins_tail = NULL;
841
842       if (payload_len > 0) {
843         GstPlugin *newplugin = NULL;
844         if (!_priv_gst_registry_chunks_load_plugin (l->registry, &tmp,
845                 tmp + payload_len, &newplugin)) {
846           /* Got garbage from the child, so fail and trigger replay of plugins */
847           GST_ERROR_OBJECT (l->registry,
848               "Problems loading plugin details with tag %u from scanner", tag);
849           return FALSE;
850         }
851
852         newplugin->flags &= ~GST_PLUGIN_FLAG_CACHED;
853         GST_LOG_OBJECT (l->registry,
854             "marking plugin %p as registered as %s", newplugin,
855             newplugin->filename);
856         newplugin->registered = TRUE;
857
858         /* We got a set of plugin details - remember it for later */
859         l->got_plugin_details = TRUE;
860       } else if (entry != NULL) {
861         /* Create a blacklist entry for this file to prevent scanning every time */
862         plugin_loader_create_blacklist_plugin (l, entry);
863         l->got_plugin_details = TRUE;
864       }
865
866       if (entry != NULL) {
867         g_free (entry->filename);
868         g_slice_free (PendingPluginEntry, entry);
869       }
870
871       /* Remove the plugin entry we just loaded */
872       cur = l->pending_plugins;
873       if (cur != NULL)
874         cur = g_list_delete_link (cur, cur);
875       l->pending_plugins = cur;
876       if (cur == NULL)
877         l->pending_plugins_tail = NULL;
878
879       break;
880     }
881     case PACKET_SYNC:
882       if (l->is_child) {
883         /* Respond with our reply - also a sync */
884         put_packet (l, PACKET_SYNC, tag, NULL, 0);
885         GST_LOG ("Got SYNC in child - replying");
886       } else
887         l->rx_got_sync = TRUE;
888       break;
889     case PACKET_VERSION:
890       if (l->is_child) {
891         /* Respond with our reply - a version packet, with the version */
892         const gint version_len =
893             sizeof (guint32) + GST_MAGIC_BINARY_VERSION_LEN;
894         guint8 version_info[sizeof (guint32) + GST_MAGIC_BINARY_VERSION_LEN];
895         memset (version_info, 0, version_len);
896         GST_WRITE_UINT32_BE (version_info, loader_protocol_version);
897         memcpy (version_info + sizeof (guint32), GST_MAGIC_BINARY_VERSION_STR,
898             strlen (GST_MAGIC_BINARY_VERSION_STR));
899         put_packet (l, PACKET_VERSION, tag, version_info, version_len);
900         GST_LOG ("Got VERSION in child - replying %u", loader_protocol_version);
901       } else {
902         res = check_protocol_version (l, payload, payload_len);
903       }
904       break;
905     default:
906       return FALSE;             /* Invalid packet -> something is wrong */
907   }
908
909   return res;
910 }
911
912 static gboolean
913 read_one (GstPluginLoader * l)
914 {
915   guint64 magic;
916   guint32 to_read, packet_len, tag;
917   guint8 *in;
918   gint res;
919
920   to_read = HEADER_SIZE;
921   in = l->rx_buf;
922   do {
923     res = read (l->fd_r.fd, in, to_read);
924     if (G_UNLIKELY (res < 0)) {
925       if (errno == EAGAIN || errno == EINTR)
926         continue;
927       GST_LOG ("Failed reading packet header");
928       return FALSE;
929     }
930     to_read -= res;
931     in += res;
932   } while (to_read > 0);
933
934   magic = GST_READ_UINT32_BE (l->rx_buf + 8);
935   if (magic != HEADER_MAGIC) {
936     GST_WARNING
937         ("Invalid packet (bad magic number) received from plugin scanner subprocess");
938     return FALSE;
939   }
940
941   packet_len = GST_READ_UINT32_BE (l->rx_buf + 4);
942   if (packet_len + HEADER_SIZE > BUF_MAX_SIZE) {
943     GST_WARNING
944         ("Received excessively large packet for plugin scanner subprocess");
945     return FALSE;
946   }
947   tag = GST_READ_UINT24_BE (l->rx_buf + 1);
948
949   if (packet_len > 0) {
950     if (packet_len + HEADER_SIZE >= l->rx_buf_size) {
951       GST_LOG ("Expanding rx buf from %d to %d",
952           l->rx_buf_size, packet_len + HEADER_SIZE + BUF_GROW_EXTRA);
953       l->rx_buf_size = packet_len + HEADER_SIZE + BUF_GROW_EXTRA;
954       l->rx_buf = g_realloc (l->rx_buf, l->rx_buf_size);
955     }
956
957     in = l->rx_buf + HEADER_SIZE;
958     to_read = packet_len;
959     do {
960       res = read (l->fd_r.fd, in, to_read);
961       if (G_UNLIKELY (res < 0)) {
962         if (errno == EAGAIN || errno == EINTR)
963           continue;
964         GST_ERROR ("Packet payload read failed");
965         return FALSE;
966       }
967       to_read -= res;
968       in += res;
969     } while (to_read > 0);
970   } else {
971     GST_LOG ("No payload to read for 0 length packet type %d tag %u",
972         l->rx_buf[0], tag);
973   }
974
975   return handle_rx_packet (l, l->rx_buf[0], tag,
976       l->rx_buf + HEADER_SIZE, packet_len);
977 }
978
979 static gboolean
980 exchange_packets (GstPluginLoader * l)
981 {
982   gint res;
983
984   /* Wait for activity on our FDs */
985   do {
986     do {
987       res = gst_poll_wait (l->fdset, GST_SECOND);
988     } while (res == -1 && (errno == EINTR || errno == EAGAIN));
989
990     if (res < 0)
991       return FALSE;
992
993     GST_LOG ("Poll res = %d. %d bytes pending for write", res,
994         l->tx_buf_write - l->tx_buf_read);
995
996     if (!l->rx_done) {
997       if (gst_poll_fd_has_error (l->fdset, &l->fd_r) ||
998           gst_poll_fd_has_closed (l->fdset, &l->fd_r)) {
999         GST_LOG ("read fd %d closed/errored", l->fd_r.fd);
1000         goto fail_and_cleanup;
1001       }
1002
1003       if (gst_poll_fd_can_read (l->fdset, &l->fd_r)) {
1004         if (!read_one (l))
1005           goto fail_and_cleanup;
1006       }
1007     }
1008
1009     if (l->tx_buf_read < l->tx_buf_write) {
1010       if (gst_poll_fd_has_error (l->fdset, &l->fd_w) ||
1011           gst_poll_fd_has_closed (l->fdset, &l->fd_r)) {
1012         GST_ERROR ("write fd %d closed/errored", l->fd_w.fd);
1013         goto fail_and_cleanup;
1014       }
1015       if (gst_poll_fd_can_write (l->fdset, &l->fd_w)) {
1016         if (!write_one (l))
1017           goto fail_and_cleanup;
1018       }
1019     }
1020   } while (l->tx_buf_read < l->tx_buf_write);
1021
1022   return TRUE;
1023 fail_and_cleanup:
1024   plugin_loader_cleanup_child (l);
1025   return FALSE;
1026 }