/* -*- mode: C; c-file-style: "gnu" -*- */

/* config-loader-libxml.c  libxml2 XML loader

 *

 * Copyright (C) 2003 Red Hat, Inc.

 * Portion Copyright © 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

 * Licensed under the Academic Free License version 2.1

 * 

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

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 * 

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

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 */

#include "config-parser.h"

#ifndef __SYMBIAN32__

#include <dbus/dbus-internals.h>

#else

#include "dbus-internals.h"

#endif //__SYMBIAN32__

#ifdef __SYMBIAN32__

#include <libxml2_xmlreader.h>

#else

#include <libxml/xmlreader.h>

#include <libxml/parser.h>

#include <libxml/globals.h>

#include <libxml/xmlmemory.h>

#endif

#include <errno.h>

#include <string.h>

/* About the error handling: 

 *  - setup a "structured" error handler that catches structural

 *    errors and some oom errors 

 *  - assume that a libxml function returning an error code means

 *    out-of-memory

 */

#define _DBUS_MAYBE_SET_OOM(e) (dbus_error_is_set(e) ? (void)0 : _DBUS_SET_OOM(e))

static dbus_bool_t

xml_text_start_element (BusConfigParser   *parser,

			xmlTextReader     *reader,

			DBusError         *error)

{

  const char *name;

  int n_attributes;

  const char **attribute_names, **attribute_values;

  dbus_bool_t ret;

  int i, status, is_empty;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  ret = FALSE;

  attribute_names = NULL;

  attribute_values = NULL;

#ifdef __SYMBIAN32__

  name = (const char *) xmlTextReaderConstName (reader);

#else

  name = xmlTextReaderConstName (reader);

#endif

  n_attributes = xmlTextReaderAttributeCount (reader);

  is_empty = xmlTextReaderIsEmptyElement (reader);

  if (name == NULL || n_attributes < 0 || is_empty == -1)

    {

      _DBUS_MAYBE_SET_OOM (error);

      goto out;

    }

  attribute_names = dbus_new0 (const char *, n_attributes + 1);

  attribute_values = dbus_new0 (const char *, n_attributes + 1);

  if (attribute_names == NULL || attribute_values == NULL)

    {

      _DBUS_SET_OOM (error);

      goto out;

    }

  i = 0;

  while ((status = xmlTextReaderMoveToNextAttribute (reader)) == 1)

    {

      _dbus_assert (i < n_attributes);

#ifdef __SYMBIAN32__

      attribute_names[i] = (const char *) xmlTextReaderConstName (reader);

      attribute_values[i] = (const char *) xmlTextReaderConstValue (reader);

#else

      attribute_names[i] = xmlTextReaderConstName (reader);

      attribute_values[i] = (xmlTextReaderConstValue (reader);

#endif

      if (attribute_names[i] == NULL || attribute_values[i] == NULL)

	{ 

          _DBUS_MAYBE_SET_OOM (error);

	  goto out;

	}

      i++;

    }

  if (status == -1)

    {

      _DBUS_MAYBE_SET_OOM (error);

      goto out;

    }

  _dbus_assert (i == n_attributes);

  ret = bus_config_parser_start_element (parser, name,

					 attribute_names, attribute_values,

					 error);

  if (ret && is_empty == 1)

    ret = bus_config_parser_end_element (parser, name, error);

 out:

  dbus_free (attribute_names);

  dbus_free (attribute_values);

  return ret;

}

static void xml_shut_up (void *ctx, const char *msg, ...)

{

    return;

}

static void

xml_text_reader_error (void *arg, xmlErrorPtr xml_error)

{

  DBusError *error = arg;

#if 0

  _dbus_verbose ("XML_ERROR level=%d, domain=%d, code=%d, msg=%s\n",

                 xml_error->level, xml_error->domain,

                 xml_error->code, xml_error->message);

#endif

  if (!dbus_error_is_set (error))

    {

      if (xml_error->code == XML_ERR_NO_MEMORY)

        _DBUS_SET_OOM (error);

      else if (xml_error->level == XML_ERR_ERROR ||

               xml_error->level == XML_ERR_FATAL)

        dbus_set_error (error, DBUS_ERROR_FAILED,

                        "Error loading config file: '%s'",

                        xml_error->message);

    }

}

BusConfigParser*

bus_config_load (const DBusString      *file,

                 dbus_bool_t            is_toplevel,

                 const BusConfigParser *parent,

                 DBusError             *error)

{

  xmlTextReader *reader;

  BusConfigParser *parser;

  DBusString dirname, data;

  DBusError tmp_error;

  int ret;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  parser = NULL;

  reader = NULL;

  if (!_dbus_string_init (&dirname))

    {

      _DBUS_SET_OOM (error);

      return NULL;

    }

  if (!_dbus_string_init (&data))

    {

      _DBUS_SET_OOM (error);

      _dbus_string_free (&dirname);

      return NULL;

    }

  if (is_toplevel)

    {

      /* xmlMemSetup only fails if one of the functions is NULL */

    /*

      xmlMemSetup (dbus_free,

                   dbus_malloc,

                   dbus_realloc,

                   _dbus_strdup);

     */              

      xmlInitParser ();

      xmlSetGenericErrorFunc (NULL, xml_shut_up);

    }

  if (!_dbus_string_get_dirname (file, &dirname))

    {

      _DBUS_SET_OOM (error);

      goto failed;

    }

  parser = bus_config_parser_new (&dirname, is_toplevel, parent);

  if (parser == NULL)

    {

      _DBUS_SET_OOM (error);

      goto failed;

    }

  if (!_dbus_file_get_contents (&data, file, error))

    goto failed;

  reader = xmlReaderForMemory (_dbus_string_get_const_data (&data), 

                               _dbus_string_get_length (&data),

			       NULL, NULL, 0);

  if (reader == NULL)

    {

      _DBUS_SET_OOM (error);

      goto failed;

    }

  xmlTextReaderSetParserProp (reader, XML_PARSER_SUBST_ENTITIES, 1);

  dbus_error_init (&tmp_error);

  xmlTextReaderSetStructuredErrorHandler (reader, xml_text_reader_error, &tmp_error);

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

    {

      int type;

      if (dbus_error_is_set (&tmp_error))

        goto reader_out;

      type = xmlTextReaderNodeType (reader);

      if (type == -1)

        {

          _DBUS_MAYBE_SET_OOM (&tmp_error);

          goto reader_out;

        }

      switch ((xmlReaderTypes) type) {

      case XML_READER_TYPE_ELEMENT:

	xml_text_start_element (parser, reader, &tmp_error);

	break;

      case XML_READER_TYPE_TEXT:

      case XML_READER_TYPE_CDATA:

	{

	  DBusString content;

	  const char *value;

#ifdef __SYMBIAN32__

	  value = (const char *) xmlTextReaderConstValue (reader);

#else

	  value = xmlTextReaderConstValue (reader);

#endif

	  if (value != NULL)

	    {

	      _dbus_string_init_const (&content, value);

	      bus_config_parser_content (parser, &content, &tmp_error);

	    }

          else

            _DBUS_MAYBE_SET_OOM (&tmp_error);

	  break;

	}

      case XML_READER_TYPE_DOCUMENT_TYPE:

	{

	  const char *name;

#ifdef __SYMBIAN32__

	  name = (const char *) xmlTextReaderConstName (reader);

#else

	  name = xmlTextReaderConstName (reader);

#endif

	  if (name != NULL)

	    bus_config_parser_check_doctype (parser, name, &tmp_error);

          else

            _DBUS_MAYBE_SET_OOM (&tmp_error);

	  break;

	}

      case XML_READER_TYPE_END_ELEMENT:

	{

	  const char *name;

#ifdef __SYMBIAN32__

	  name = (const char *) xmlTextReaderConstName (reader);

#else

	  name = xmlTextReaderConstName (reader);

#endif

	  if (name != NULL)

	    bus_config_parser_end_element (parser, name, &tmp_error);

          else

            _DBUS_MAYBE_SET_OOM (&tmp_error);

	  break;

	}

      case XML_READER_TYPE_DOCUMENT:

      case XML_READER_TYPE_DOCUMENT_FRAGMENT:

      case XML_READER_TYPE_PROCESSING_INSTRUCTION:

      case XML_READER_TYPE_COMMENT:

      case XML_READER_TYPE_ENTITY:

      case XML_READER_TYPE_NOTATION:

      case XML_READER_TYPE_WHITESPACE:

      case XML_READER_TYPE_SIGNIFICANT_WHITESPACE:

      case XML_READER_TYPE_END_ENTITY:

      case XML_READER_TYPE_XML_DECLARATION:

	/* nothing to do, just read on */

	break;

      case XML_READER_TYPE_NONE:

      case XML_READER_TYPE_ATTRIBUTE:

      case XML_READER_TYPE_ENTITY_REFERENCE:

	_dbus_assert_not_reached ("unexpected nodes in XML");

      }

      if (dbus_error_is_set (&tmp_error))

        goto reader_out;

    }

  if (ret == -1)

    _DBUS_MAYBE_SET_OOM (&tmp_error);

 reader_out:

  xmlFreeTextReader (reader);

  reader = NULL;

  if (dbus_error_is_set (&tmp_error))

    {

      dbus_move_error (&tmp_error, error);

      goto failed;

    }

  if (!bus_config_parser_finished (parser, error))

    goto failed;

  _dbus_string_free (&dirname);

  _dbus_string_free (&data);

  if (is_toplevel)

    xmlCleanupParser();

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  return parser;

 failed:

  _DBUS_ASSERT_ERROR_IS_SET (error);

  _dbus_string_free (&dirname);

  _dbus_string_free (&data);

  if (is_toplevel)

    xmlCleanupParser();

  if (parser)

    bus_config_parser_unref (parser);

  _dbus_assert (reader == NULL); /* must go to reader_out first */

  return NULL;

}