/* 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

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

/* FIXME:

 * - keep registry binary blob and reference strings

 *   - don't free/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

 *     - 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

 */

#ifdef HAVE_CONFIG_H

#  include "config.h"

#endif

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <errno.h>

#include <stdio.h>

#if defined (_MSC_VER) && _MSC_VER >= 1400

#include <io.h>

#endif

#include <gst/gst_private.h>

#include <gst/gstconfig.h>

#include <gst/gstelement.h>

#include <gst/gsttypefind.h>

#include <gst/gsttypefindfactory.h>

#include <gst/gstdeviceproviderfactory.h>

#include <gst/gstdynamictypefactory.h>

#include <gst/gsturi.h>

#include <gst/gstinfo.h>

#include <gst/gstenumtypes.h>

#include <gst/gstpadtemplate.h>

#include <gst/gstregistrychunks.h>

#include <gst/gstregistrybinary.h>

#include <glib/gstdio.h>        /* for g_stat(), g_mapped_file(), ... */

#include "glib-compat-private.h"

#define GST_CAT_DEFAULT GST_CAT_REGISTRY

/* 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 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_slice_new0 (BinaryRegistryCache);

  cache->location = location;

  return cache;

}

static int

gst_registry_binary_cache_write (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 (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)) {

      /* 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_slice_free (BinaryRegistryCache, cache);

  return ret;

}

#else

typedef struct BinaryRegistryCache

{

  const char *location;

  char *tmp_location;

  unsigned long currentoffset;

  int cache_fd;

} BinaryRegistryCache;

static BinaryRegistryCache *

gst_registry_binary_cache_init (GstRegistry * registry, const char *location)

{

  BinaryRegistryCache *cache = g_slice_new0 (BinaryRegistryCache);

  cache->location = location;

  cache->tmp_location = g_strconcat (location, ".tmpXXXXXX", NULL);

  cache->cache_fd = g_mkstemp (cache->tmp_location);

  if (cache->cache_fd == -1) {

    int ret;

    GStatBuf statbuf;

    gchar *dir;

    /* oops, I bet the directory doesn't exist */

    dir = g_path_get_dirname (location);

    g_mkdir_with_parents (dir, 0777);

    ret = g_stat (dir, &statbuf);

    if (ret != -1 && (statbuf.st_mode & 0700) != 0700) {

      g_chmod (dir, 0700);

    }

    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);

    cache->cache_fd = g_mkstemp (cache->tmp_location);

    if (cache->cache_fd == -1) {

      GST_DEBUG ("g_mkstemp() failed: %s", g_strerror (errno));

      g_free (cache->tmp_location);

      g_slice_free (BinaryRegistryCache, cache);

      return NULL;

    }

    ret = g_stat (cache->tmp_location, &statbuf);

    if (ret != -1 && (statbuf.st_mode & 0600) != 0600) {

      g_chmod (cache->tmp_location, 0600);

    }

  }

  return cache;

}

static int

gst_registry_binary_cache_write (BinaryRegistryCache * cache,

    unsigned long offset, const void *data, int length)

{

  long written;

  if (offset != cache->currentoffset) {

    if (lseek (cache->cache_fd, offset, SEEK_SET) < 0) {

      GST_ERROR ("Seeking to new offset failed: %s", g_strerror (errno));

      return -1;

    }

    GST_LOG ("Seeked from offset %lu to %lu", offset, cache->currentoffset);

    cache->currentoffset = offset;

  }

  written = write (cache->cache_fd, 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 (BinaryRegistryCache * cache, gboolean success)

{

  /* only fsync if we're actually going to use and rename the file below */

  if (success && fsync (cache->cache_fd) < 0)

    goto fsync_failed;

  if (close (cache->cache_fd) < 0)

    goto close_failed;

  if (!success)

    goto fail_after_close;

  /* Only do the rename if we wrote the entire file successfully */

  if (g_rename (cache->tmp_location, cache->location) < 0) {

    GST_ERROR ("g_rename() failed: %s", g_strerror (errno));

    goto rename_failed;

  }

  g_free (cache->tmp_location);

  g_slice_free (BinaryRegistryCache, cache);

  GST_INFO ("Wrote binary registry cache");

  return TRUE;

/* ERRORS */

fail_after_close:

  {

    g_unlink (cache->tmp_location);

    g_free (cache->tmp_location);

    g_slice_free (BinaryRegistryCache, 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_chunk:

 *

 * Write from a memory location to the registry cache file

 *

 * Returns: %TRUE for success

 */

inline static gboolean

gst_registry_binary_write_chunk (BinaryRegistryCache * cache,

    GstRegistryChunk * chunk, unsigned long *file_position)

{

  gchar padder[ALIGNMENT] = { 0, };

  int padsize = 0;

  /* Padding to insert the struct that requiere word alignment */

  if ((chunk->align) && (alignment (*file_position) != 0)) {

    padsize = ALIGNMENT - alignment (*file_position);

    if (gst_registry_binary_cache_write (cache, *file_position,

            padder, padsize) != padsize) {

      GST_ERROR ("Failed to write binary registry padder");

      return FALSE;

    }

    *file_position += padsize;

  }

  if (gst_registry_binary_cache_write (cache, *file_position,

          chunk->data, chunk->size) != chunk->size) {

    GST_ERROR ("Failed to write binary registry element");

    return FALSE;

  }

  *file_position += chunk->size;

  return TRUE;

}

/*

 * gst_registry_binary_initialize_magic:

 *

 * Initialize the GstBinaryRegistryMagic, setting both our magic number and

 * gstreamer major/minor version

 */

inline static gboolean

gst_registry_binary_initialize_magic (GstBinaryRegistryMagic * m)

{

  memset (m, 0, sizeof (GstBinaryRegistryMagic));

  if (!memcpy (m->magic, GST_MAGIC_BINARY_REGISTRY_STR,

          GST_MAGIC_BINARY_REGISTRY_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;

}

/**

 * gst_registry_binary_write_cache:

 * @registry: a #GstRegistry

 * @location: a filename

 *

 * Write the @registry to a cache to file at given @location.

 *

 * Returns: %TRUE on success.

 */

gboolean

priv_gst_registry_binary_write_cache (GstRegistry * registry, GList * plugins,

    const char *location)

{

  GList *walk;

  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);

  if (!gst_registry_binary_initialize_magic (&magic))

    goto fail;

  /* iterate trough the list of plugins and fit them into binary structures */

  for (walk = plugins; walk != NULL; walk = walk->next) {

    GstPlugin *plugin = GST_PLUGIN (walk->data);

    if (!plugin->filename)

      continue;

    if (GST_OBJECT_FLAG_IS_SET (plugin, GST_PLUGIN_FLAG_CACHED)) {

      GStatBuf statbuf;

      if (g_stat (plugin->filename, &statbuf) < 0 ||

          plugin->file_mtime != statbuf.st_mtime ||

          plugin->file_size != statbuf.st_size)

        continue;

    }

    if (!_priv_gst_registry_chunks_save_plugin (&to_write, registry, plugin)) {

      GST_ERROR ("Can't write binary plugin information for \"%s\"",

          plugin->filename);

    }

  }

  _priv_gst_registry_chunks_save_global_header (&to_write, registry,

      priv_gst_plugin_loading_get_whitelist_hash ());

  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 (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)) {

    GstRegistryChunk *cur = walk->data;

    gboolean res;

    res = gst_registry_binary_write_chunk (cache, cur, &file_position);

    _priv_gst_registry_chunk_free (cur);

    walk->data = NULL;

    if (!res)

      goto fail_free_list;

  }

  g_list_free (to_write);

  if (!gst_registry_binary_cache_finish (cache, TRUE))

    return FALSE;

  return TRUE;

  /* Errors */

fail_free_list:

  {

    for (walk = to_write; walk; walk = g_list_next (walk)) {

      GstRegistryChunk *cur = walk->data;

      if (cur)

        _priv_gst_registry_chunk_free (cur);

    }

    g_list_free (to_write);

    if (cache)

      (void) gst_registry_binary_cache_finish (cache, FALSE);

    /* fall through */

  }

fail:

  {

    return FALSE;

  }

}

/* Registry loading */

/*

 * gst_registry_binary_check_magic:

 *

 * Check GstBinaryRegistryMagic validity.

 * 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 gint

gst_registry_binary_check_magic (gchar ** in, gsize size)

{

  GstBinaryRegistryMagic *m;

  align (*in);

  GST_DEBUG ("Reading/casting for GstBinaryRegistryMagic at address %p", *in);

  unpack_element (*in, m, GstBinaryRegistryMagic, (*in + size), fail);

  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 -1;

  }

  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_MAGIC_BINARY_VERSION_STR, m->version);

    return -2;

  }

  return 0;

fail:

  GST_WARNING ("Not enough data for binary registry magic structure");

  return -1;

}

/**

 * gst_registry_binary_read_cache:

 * @registry: a #GstRegistry

 * @location: a filename

 *

 * Read the contents of the binary cache file at @location into @registry.

 *

 * Returns: %TRUE on success.

 */

gboolean

priv_gst_registry_binary_read_cache (GstRegistry * registry,

    const char *location)

{

  GMappedFile *mapped = NULL;

  gchar *contents = NULL;

  gchar *in = NULL;

  gsize size;

  GError *err = NULL;

  gboolean res = FALSE;

  guint32 filter_env_hash = 0;

  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;

  GST_TYPE_DEVICE_PROVIDER_FACTORY;

  GST_TYPE_DYNAMIC_TYPE_FACTORY;

#ifndef GST_DISABLE_GST_DEBUG

  timer = g_timer_new ();

#endif

  mapped = g_mapped_file_new (location, FALSE, &err;;

  if (G_UNLIKELY (err != NULL)) {

    GST_INFO ("Unable to mmap file %s : %s", location, err->message);

    g_error_free (err);

    err = NULL;

  }

  if (mapped == NULL) {

    /* Error mmap-ing the cache, try a plain memory read */

    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 {

    /* This can't fail if g_mapped_file_new() succeeded */

    contents = g_mapped_file_get_contents (mapped);

    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 (G_UNLIKELY (size < sizeof (GstBinaryRegistryMagic))) {

    GST_ERROR ("No or broken registry header for file at %s", location);

    goto Error;

  }

  /* check if header is valid */

  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;

  }

  if (!_priv_gst_registry_chunks_load_global_header (registry, &in,

          contents + size, &filter_env_hash)) {

    GST_ERROR ("Couldn't read global header chunk");

    goto Error;

  }

  if (filter_env_hash != priv_gst_plugin_loading_get_whitelist_hash ()) {

    GST_INFO_OBJECT (registry, "Plugin loading filter environment changed, "

        "ignoring plugin cache to force update with new filter environment");

    goto done;

  }

  /* check if there are plugins in the file */

  if (G_UNLIKELY (!(((gsize) in + sizeof (GstRegistryChunkPluginElement)) <

              (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 GstRegistryChunkPluginElement */

    for (;

        ((gsize) in + sizeof (GstRegistryChunkPluginElement)) <

        (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 (!_priv_gst_registry_chunks_load_plugin (registry, &in, end, NULL)) {

        GST_ERROR ("Problem while reading binary registry %s", location);

        goto Error;

      }

    }

  }

done:

#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 */

Error:

#ifndef GST_DISABLE_GST_DEBUG

  g_timer_destroy (timer);

#endif

  if (mapped) {

    g_mapped_file_unref (mapped);

  } else {

    g_free (contents);

  }

  return res;

}