/* 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., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/* FIXME:

 * - keep registry binary blob and reference strings

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

 *     - 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/gsturi.h>

#include <gst/gstinfo.h>

#include <gst/gstenumtypes.h>

#include <gst/gstpadtemplate.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

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

  while (*str++ != '\0') {

    len++;

    if (G_UNLIKELY (len == maxlen))

      return -1;

  }

  return len;

}

/* reading macros */

#define unpack_element(inptr, outptr, element, endptr, error_label) G_STMT_START{ \

  if (inptr + sizeof(element) >= endptr) \

    goto error_label; \

  outptr = (element *) inptr; \

  inptr += sizeof (element); \

}G_STMT_END

#define unpack_const_string(inptr, outptr, endptr, error_label) G_STMT_START{\

  gint _len = _strnlen (inptr, (endptr-inptr)); \

  if (_len == -1) \

    goto error_label; \

  outptr = g_intern_string ((const gchar *)inptr); \

  inptr += _len + 1; \

}G_STMT_END

#define unpack_string(inptr, outptr, endptr, error_label)  G_STMT_START{\

  gint _len = _strnlen (inptr, (endptr-inptr)); \

  if (_len == -1) \

    goto error_label; \

  outptr = g_memdup ((gconstpointer)inptr, _len + 1); \

  inptr += _len + 1; \

}G_STMT_END

#define ALIGNMENT            (sizeof (void *))

#define alignment(_address)  (gsize)_address%ALIGNMENT

#define align(_ptr)          _ptr += (( alignment(_ptr) == 0) ? 0 : ALIGNMENT-alignment(_ptr))

/* Registry saving */

#ifdef G_OS_WIN32

/* On win32, we can't use g_mkstmp(), because of cross-DLL file I/O problems.

 * So, we just create the entire binary registry in memory, then write it out

 * with g_file_set_contents(), which creates a temporary file internally

 */

typedef struct BinaryRegistryCache

{

  const char *location;

  guint8 *mem;

  gssize len;

} BinaryRegistryCache;

static BinaryRegistryCache *

gst_registry_binary_cache_init (GstRegistry * registry, const char *location)

{

  BinaryRegistryCache *cache = g_new0 (BinaryRegistryCache, 1);

  cache->location = location;

  return cache;

}

static int

gst_registry_binary_cache_write (GstRegistry * registry,

    BinaryRegistryCache * cache, unsigned long offset,

    const void *data, int length)

{

  cache->len = MAX (offset + length, cache->len);

  cache->mem = g_realloc (cache->mem, cache->len);

  memcpy (cache->mem + offset, data, length);

  return length;

}

static gboolean

gst_registry_binary_cache_finish (GstRegistry * registry,

    BinaryRegistryCache * cache, gboolean success)

{

  gboolean ret = TRUE;

  GError *error = NULL;

  if (!g_file_set_contents (cache->location, (const gchar *) cache->mem,

          cache->len, &error)) {

    /* Probably the directory didn't exist; create it */

    gchar *dir;

    dir = g_path_get_dirname (cache->location);

    g_mkdir_with_parents (dir, 0777);

    g_free (dir);

    g_error_free (error);

    error = NULL;

    if (!g_file_set_contents (cache->location, (const gchar *) cache->mem,

            cache->len, &error)) {

      GST_ERROR ("Failed to write to cache file: %s", error->message);

      g_error_free (error);

      ret = FALSE;

    }

  }

  g_free (cache->mem);

  g_free (cache);

  return ret;

}

#else

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_chunk:

 *

 * Write from a memory location to the registry cache file

 *

 * Returns: %TRUE for success

 */

inline static gboolean

gst_registry_binary_write_chunk (GstRegistry * registry,

    BinaryRegistryCache * cache, const void *mem,

    const gssize size, unsigned long *file_position, gboolean align)

{

  gchar padder[ALIGNMENT] = { 0, };

  int padsize = 0;

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

  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 += padsize;

  }

  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 += 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 (!strncpy (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_save_const_string:

 *

 * Store a const string in a binary chunk.

 *

 * Returns: %TRUE for success

 */

inline static gboolean

gst_registry_binary_save_const_string (GList ** list, const gchar * str)

{

  GstBinaryChunk *chunk;

  if (G_UNLIKELY (str == NULL)) {

    GST_ERROR ("unexpected NULL string in plugin or plugin feature data");

    str = "";

  }

  chunk = g_malloc (sizeof (GstBinaryChunk));

  chunk->data = (gpointer) str;

  chunk->size = strlen ((gchar *) chunk->data) + 1;

  chunk->flags = GST_BINARY_REGISTRY_FLAG_CONST;

  chunk->align = FALSE;

  *list = g_list_prepend (*list, chunk);

  return TRUE;

}

/*

 * gst_registry_binary_save_string:

 *

 * Store a string in a binary chunk.

 *

 * Returns: %TRUE for success

 */

inline static gboolean

gst_registry_binary_save_string (GList ** list, gchar * str)

{

  GstBinaryChunk *chunk;

  chunk = g_malloc (sizeof (GstBinaryChunk));

  chunk->data = str;

  chunk->size = strlen ((gchar *) chunk->data) + 1;

  chunk->flags = GST_BINARY_REGISTRY_FLAG_NONE;

  chunk->align = FALSE;

  *list = g_list_prepend (*list, chunk);

  return TRUE;

}

/*

 * gst_registry_binary_save_data:

 *

 * Store some data in a binary chunk.

 *

 * Returns: the initialized chunk

 */

inline static GstBinaryChunk *

gst_registry_binary_make_data (gpointer data, gulong size)

{

  GstBinaryChunk *chunk;

  chunk = g_malloc (sizeof (GstBinaryChunk));

  chunk->data = data;

  chunk->size = size;

  chunk->flags = GST_BINARY_REGISTRY_FLAG_NONE;

  chunk->align = TRUE;

  return chunk;

}

/*

 * gst_registry_binary_save_pad_template:

 *

 * Store pad_templates in binary chunks.

 *

 * Returns: %TRUE for success

 */

static gboolean

gst_registry_binary_save_pad_template (GList ** list,

    GstStaticPadTemplate * template)

{

  GstBinaryPadTemplate *pt;

  GstBinaryChunk *chk;

  pt = g_malloc0 (sizeof (GstBinaryPadTemplate));

  chk = gst_registry_binary_make_data (pt, sizeof (GstBinaryPadTemplate));

  pt->presence = template->presence;

  pt->direction = template->direction;

  /* pack pad template strings */

  gst_registry_binary_save_const_string (list,

      (gchar *) (template->static_caps.string));

  gst_registry_binary_save_const_string (list, template->name_template);

  *list = g_list_prepend (*list, chk);

  return TRUE;

}

/*

 * gst_registry_binary_save_feature:

 *

 * Store features in binary chunks.

 *

 * Returns: %TRUE for success

 */

static gboolean

gst_registry_binary_save_feature (GList ** list, GstPluginFeature * feature)

{

  const gchar *type_name = g_type_name (G_OBJECT_TYPE (feature));

  GstBinaryPluginFeature *pf = NULL;

  GstBinaryChunk *chk = NULL;

  GList *walk;

  if (!type_name) {

    GST_ERROR ("NULL feature type_name, aborting.");

    return FALSE;

  }

  if (GST_IS_ELEMENT_FACTORY (feature)) {

    GstBinaryElementFactory *ef;

    GstElementFactory *factory = GST_ELEMENT_FACTORY (feature);

    ef = g_malloc0 (sizeof (GstBinaryElementFactory));

    chk = gst_registry_binary_make_data (ef, sizeof (GstBinaryElementFactory));

    ef->npadtemplates = ef->ninterfaces = ef->nuriprotocols = 0;

    pf = (GstBinaryPluginFeature *) ef;

    /* save interfaces */

    for (walk = factory->interfaces; walk;

        walk = g_list_next (walk), ef->ninterfaces++) {

      gst_registry_binary_save_const_string (list, (gchar *) walk->data);

    }

    GST_DEBUG ("Saved %d Interfaces", ef->ninterfaces);

    /* save uritypes */

    if (GST_URI_TYPE_IS_VALID (factory->uri_type)) {

      if (factory->uri_protocols && *factory->uri_protocols) {

        GstBinaryChunk *subchk;

        gchar **protocol;

        subchk =

            gst_registry_binary_make_data (&factory->uri_type,

            sizeof (factory->uri_type));

        subchk->flags = GST_BINARY_REGISTRY_FLAG_CONST;

        protocol = factory->uri_protocols;

        while (*protocol) {