/* GStreamer

 * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>

 *                    2000 Wim Taymans <wtay@chello.be>

 *                    2005 David A. Schleef <ds@schleef.org>

 *

 * gstregistryxml.c: GstRegistry object, support routines

 *

 * This library is free software; you can redistribute it and/or

 * modify it ulnder 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.

 */

#ifdef HAVE_CONFIG_H

#  include "config.h"

#endif

#include <stdio.h>

#include <errno.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <dirent.h>

#include <fcntl.h>

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <gst/gst_private.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/gstregistry.h>

#include <libxml/xmlreader.h>

#include "glib-compat-private.h"

#include <glib/gstdio.h>

#define BLOCK_SIZE 1024*10

#define GST_CAT_DEFAULT GST_CAT_REGISTRY

#define CLASS(registry)  GST_XML_REGISTRY_CLASS (G_OBJECT_GET_CLASS (registry))

static gboolean

gst_registry_save (GstRegistry * registry, gchar * format, ...)

{

  va_list var_args;

  gsize written, len;

  gboolean ret;

  char *str;

  va_start (var_args, format);

  str = g_strdup_vprintf (format, var_args);

  va_end (var_args);

  len = strlen (str);

  written = write (registry->cache_file, str, len);

  if (len == written)

    ret = TRUE;

  else {

    ret = FALSE;

    GST_ERROR ("Failed to write registry to temporary file: %s",

        g_strerror (errno));

  }

  g_free (str);

  return ret;

}

static void

add_to_char_array (gchar *** array, gchar * value)

{

  gchar **new;

  gchar **old = *array;

  gint i = 0;

  /* expensive, but cycles are cheap... */

  if (old)

    while (old[i])

      i++;

  new = g_new0 (gchar *, i + 2);

  new[i] = value;

  while (i > 0) {

    i--;

    new[i] = old[i];

  }

  g_free (old);

  *array = new;

}

/* read a string and copy it into the given location */

static gboolean

read_string (xmlTextReaderPtr reader, gchar ** write_to, gboolean allow_blank)

{

  int depth = xmlTextReaderDepth (reader);

  gboolean found = FALSE;

  while (xmlTextReaderRead (reader) == 1) {

    if (xmlTextReaderDepth (reader) == depth) {

      if (allow_blank && !found &&

          xmlTextReaderNodeType (reader) == XML_READER_TYPE_END_ELEMENT) {

        /* Allow blank strings */

        *write_to = g_strdup ("");

        found = TRUE;

      }

      return found;

    }

    if (xmlTextReaderNodeType (reader) == XML_READER_TYPE_TEXT) {

      xmlChar *value;

      if (found)

        return FALSE;

      value = xmlTextReaderValue (reader);

      *write_to = g_strdup ((gchar *) value);

      xmlFree (value);

      found = TRUE;

    }

  }

  return FALSE;

}

static gboolean

read_const_interned_string (xmlTextReaderPtr reader, const gchar ** write_to,

    gboolean allow_blank)

{

  gchar *s = NULL;

  if (!read_string (reader, &s, allow_blank))

    return FALSE;

  *write_to = g_intern_string (s);

  g_free (s);

  return TRUE;

}

static gboolean

read_uint (xmlTextReaderPtr reader, guint * write_to)

{

  int depth = xmlTextReaderDepth (reader);

  gboolean found = FALSE;

  while (xmlTextReaderRead (reader) == 1) {

    if (xmlTextReaderDepth (reader) == depth)

      return found;

    if (xmlTextReaderNodeType (reader) == XML_READER_TYPE_TEXT) {

      gchar *ret;

      const gchar *s;

      if (found) {

        GST_DEBUG ("failed to read uint, multiple text nodes");

        return FALSE;

      }

      s = (const gchar *) xmlTextReaderConstValue (reader);

      *write_to = strtol (s, &ret, 0);

      if (s == ret) {

        GST_DEBUG ("failed to read uint, text didn't convert to int");

        return FALSE;

      }

      found = TRUE;

    }

  }

  GST_DEBUG ("failed to read uint, no text node");

  return FALSE;

}

static gboolean

read_enum (xmlTextReaderPtr reader, GType enum_type, guint * write_to)

{

  int depth = xmlTextReaderDepth (reader);

  gboolean found = FALSE;

  if (*write_to)

    return FALSE;

  while (xmlTextReaderRead (reader) == 1) {

    if (xmlTextReaderDepth (reader) == depth)

      return found;

    if (xmlTextReaderNodeType (reader) == XML_READER_TYPE_TEXT) {

      GEnumClass *enum_class;

      GEnumValue *value;

      if (found)

        return FALSE;

      enum_class = g_type_class_ref (enum_type);

      if (!enum_class)

        return FALSE;

      value =

          g_enum_get_value_by_nick (enum_class,

          (gchar *) xmlTextReaderConstValue (reader));

      if (value) {

        *write_to = value->value;

        found = TRUE;

      }

      g_type_class_unref (enum_class);

    }

  }

  return FALSE;

}

static GstStaticPadTemplate *

load_pad_template (xmlTextReaderPtr reader)

{

  int ret;

  int depth = xmlTextReaderDepth (reader);

  const gchar *name = NULL;

  gchar *caps_str = NULL;

  guint direction = 0, presence = 0;

  while ((ret = xmlTextReaderRead (reader)) == 1) {

    if (xmlTextReaderDepth (reader) == depth) {

      GstStaticPadTemplate *template;

      template = g_new0 (GstStaticPadTemplate, 1);

      template->name_template = name;   /* must be an interned string! */

      template->presence = presence;

      template->direction = direction;

      template->static_caps.string = caps_str;

      return template;

    }

    if (xmlTextReaderNodeType (reader) == XML_READER_TYPE_ELEMENT &&

        xmlTextReaderDepth (reader) == depth + 1) {

      const gchar *tag = (gchar *) xmlTextReaderConstName (reader);

      if (g_str_equal (tag, "nametemplate")) {

        read_const_interned_string (reader, &name, FALSE);

      } else if (g_str_equal (tag, "direction")) {

        read_enum (reader, GST_TYPE_PAD_DIRECTION, &direction);

      } else if (g_str_equal (tag, "presence")) {

        read_enum (reader, GST_TYPE_PAD_PRESENCE, &presence);

      } else if (!strncmp (tag, "caps", 4)) {

        read_string (reader, &caps_str, FALSE);

      }

    }

  }

  g_free (caps_str);

  return NULL;

}

static GstPluginFeature *

load_feature (xmlTextReaderPtr reader)

{

  int ret;

  int depth;

  xmlChar *feature_name;

  GstPluginFeature *feature;

  GType type;

  depth = xmlTextReaderDepth (reader);

  feature_name = xmlTextReaderGetAttribute (reader, BAD_CAST "typename");

  GST_LOG ("loading feature '%s'", GST_STR_NULL ((const char *) feature_name));

  if (!feature_name)

    return NULL;

  type = g_type_from_name ((const char *) feature_name);

  xmlFree (feature_name);

  feature_name = NULL;

  if (!type) {

    return NULL;

  }

  feature = g_object_new (type, NULL);

  if (!feature) {

    return NULL;

  }

  if (!GST_IS_PLUGIN_FEATURE (feature)) {

    /* don't really know what it is */

    if (GST_IS_OBJECT (feature))

      gst_object_unref (feature);

    else

      g_object_unref (feature);

    return NULL;

  }

  while ((ret = xmlTextReaderRead (reader)) == 1) {

    if (xmlTextReaderDepth (reader) == depth) {

      GST_LOG ("loaded feature %p with name %s", feature, feature->name);

      return feature;

    }

    if (xmlTextReaderNodeType (reader) == XML_READER_TYPE_ELEMENT &&

        xmlTextReaderDepth (reader) == depth + 1) {

      const gchar *tag = (gchar *) xmlTextReaderConstName (reader);

      if (g_str_equal (tag, "name"))

        read_string (reader, &feature->name, FALSE);

      else if (g_str_equal (tag, "rank"))

        read_uint (reader, &feature->rank);

      if (GST_IS_ELEMENT_FACTORY (feature)) {

        GstElementFactory *factory = GST_ELEMENT_FACTORY_CAST (feature);

        if (g_str_equal (tag, "longname")) {

          int ret;

          ret = read_string (reader, &factory->details.longname, TRUE);

          GST_LOG ("longname ret=%d, name=%s", ret, factory->details.longname);

        } else if (g_str_equal (tag, "class")) {

          read_string (reader, &factory->details.klass, TRUE);

        } else if (g_str_equal (tag, "description")) {

          read_string (reader, &factory->details.description, TRUE);

        } else if (g_str_equal (tag, "author")) {

          read_string (reader, &factory->details.author, TRUE);

        } else if (g_str_equal (tag, "uri_type")) {

          gchar *s = NULL;

          if (read_string (reader, &s, FALSE)) {

            if (g_ascii_strncasecmp (s, "sink", 4) == 0) {

              factory->uri_type = GST_URI_SINK;

            } else if (g_ascii_strncasecmp (s, "source", 5) == 0) {

              factory->uri_type = GST_URI_SRC;

            }

            g_free (s);

          }

        } else if (g_str_equal (tag, "uri_protocol")) {

          gchar *s = NULL;

          if (read_string (reader, &s, FALSE))

            add_to_char_array (&factory->uri_protocols, s);

        } else if (g_str_equal (tag, "interface")) {

          gchar *s = NULL;

          if (read_string (reader, &s, FALSE)) {

            __gst_element_factory_add_interface (factory, s);

            /* add_interface strdup's s */

            g_free (s);

          }

        } else if (g_str_equal (tag, "padtemplate")) {

          GstStaticPadTemplate *template = load_pad_template (reader);

          if (template) {

            GST_LOG ("adding template %s to factory %s",

                GST_STR_NULL (GST_PAD_TEMPLATE_NAME_TEMPLATE (template)),

                GST_PLUGIN_FEATURE_NAME (feature));

            __gst_element_factory_add_static_pad_template (factory, template);

          }

        }

      } else if (GST_IS_TYPE_FIND_FACTORY (feature)) {

        GstTypeFindFactory *factory = GST_TYPE_FIND_FACTORY (feature);

        if (g_str_equal (tag, "extension")) {

          gchar *s = NULL;

          if (read_string (reader, &s, TRUE))

            add_to_char_array (&factory->extensions, s);

        } else if (g_str_equal (tag, "caps")) {

          gchar *s = NULL;

          if (read_string (reader, &s, FALSE)) {

            factory->caps = gst_caps_from_string (s);

            g_free (s);

          }

        }

#ifndef GST_DISABLE_INDEX

      } else if (GST_IS_INDEX_FACTORY (feature)) {

        GstIndexFactory *factory = GST_INDEX_FACTORY (feature);

        if (g_str_equal (tag, "longdesc"))

          read_string (reader, &factory->longdesc, TRUE);

#endif

      }

    }

  }

  GST_WARNING ("Error reading feature from registry: registry corrupt?");

  return NULL;

}

static GstPlugin *

load_plugin (xmlTextReaderPtr reader, GList ** feature_list)

{

  int ret;

  GstPlugin *plugin;

  *feature_list = NULL;

  GST_LOG ("creating new plugin and parsing");

  plugin = g_object_new (GST_TYPE_PLUGIN, NULL);

  plugin->flags |= GST_PLUGIN_FLAG_CACHED;

  while ((ret = xmlTextReaderRead (reader)) == 1) {

    if (xmlTextReaderDepth (reader) == 1) {

      return plugin;

    }

    if (xmlTextReaderNodeType (reader) == XML_READER_TYPE_ELEMENT &&

        xmlTextReaderDepth (reader) == 2) {

      const gchar *tag = (gchar *) xmlTextReaderConstName (reader);

      if (g_str_equal (tag, "name")) {

        int ret;

        ret = read_const_interned_string (reader, &plugin->desc.name, FALSE);

        GST_LOG ("name ret=%d, name=%s", ret, plugin->desc.name);

        if (!ret)

          break;

      } else if (g_str_equal (tag, "description")) {

        if (!read_string (reader, &plugin->desc.description, TRUE)) {

          GST_WARNING ("description field was invalid in registry");

          break;

        }

        GST_LOG ("description %s", plugin->desc.description);

      } else if (g_str_equal (tag, "filename")) {

        if (!read_string (reader, &plugin->filename, FALSE)) {

          GST_WARNING ("filename field was invalid in registry");

          break;

        }

        GST_LOG ("filename %s", plugin->filename);

        plugin->basename = g_path_get_basename (plugin->filename);

      } else if (g_str_equal (tag, "version")) {

        if (!read_const_interned_string (reader, &plugin->desc.version, TRUE)) {

          GST_WARNING ("version field was invalid in registry");

          break;

        }

        GST_LOG ("version %s", plugin->desc.version);

      } else if (g_str_equal (tag, "license")) {

        if (!read_const_interned_string (reader, &plugin->desc.license, TRUE)) {

          GST_WARNING ("license field was invalid in registry");

          break;

        }

        GST_LOG ("license %s", plugin->desc.license);

      } else if (g_str_equal (tag, "source")) {

        if (!read_const_interned_string (reader, &plugin->desc.source, TRUE)) {

          GST_WARNING ("source field was invalid in registry");

          break;

        }

        GST_LOG ("source %s", plugin->desc.source);

      } else if (g_str_equal (tag, "package")) {

        if (!read_const_interned_string (reader, &plugin->desc.package, TRUE)) {

          GST_WARNING ("package field was invalid in registry");

          break;

        }

        GST_LOG ("package %s", plugin->desc.package);

      } else if (g_str_equal (tag, "origin")) {

        if (!read_const_interned_string (reader, &plugin->desc.origin, TRUE)) {

          GST_WARNING ("failed to read origin");

          break;

        }

      } else if (g_str_equal (tag, "m32p")) {

        char *s;

        if (!read_string (reader, &s, FALSE)) {

          GST_WARNING ("failed to read mtime");

          break;

        }

        plugin->file_mtime = strtol (s, NULL, 0);

        GST_LOG ("mtime %d", (int) plugin->file_mtime);

        g_free (s);

      } else if (g_str_equal (tag, "size")) {

        unsigned int x;

        if (read_uint (reader, &x)) {

          plugin->file_size = x;

          GST_LOG ("file_size %" G_GINT64_FORMAT, (gint64) plugin->file_size);

        } else {

          GST_WARNING ("failed to read size");

        }

      } else if (g_str_equal (tag, "feature")) {

        GstPluginFeature *feature = load_feature (reader);

        if (feature) {

          feature->plugin_name = plugin->desc.name;     /* interned string */

          *feature_list = g_list_prepend (*feature_list, feature);

        }

      } else {

        GST_WARNING ("unknown tag %s", tag);

      }

    }

  }

  gst_object_unref (plugin);

  GST_WARNING ("problem reading plugin");

  return NULL;

}

/**

 * gst_registry_xml_read_cache:

 * @registry: a #GstRegistry

 * @location: a filename

 *

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

 *

 * Returns: %TRUE on success.

 */

gboolean

gst_registry_xml_read_cache (GstRegistry * registry, const char *location)

{

  GMappedFile *mapped = NULL;

  GTimer *timer;

  gdouble seconds;

  xmlTextReaderPtr reader = NULL;

  int ret;

  gboolean in_registry = FALSE;

  FILE *file = NULL;

  /* make sure these types exist */

  GST_TYPE_ELEMENT_FACTORY;

  GST_TYPE_TYPE_FIND_FACTORY;

#ifndef GST_DISABLE_INDEX

  GST_TYPE_INDEX_FACTORY;

#endif

  timer = g_timer_new ();

  mapped = g_mapped_file_new (location, FALSE, NULL);

  if (mapped) {

    reader = xmlReaderForMemory (g_mapped_file_get_contents (mapped),

        g_mapped_file_get_length (mapped), NULL, NULL, 0);