1: /* -*- mode: C; c-file-style: "gnu" -*- */
    2: /* config-loader-libxml.c  libxml2 XML loader
    3:  *
    4:  * Copyright (C) 2003 Red Hat, Inc.
    5:  *
    6:  * Licensed under the Academic Free License version 2.1
    7:  * 
    8:  * This program is free software; you can redistribute it and/or modify
    9:  * it under the terms of the GNU General Public License as published by
   10:  * the Free Software Foundation; either version 2 of the License, or
   11:  * (at your option) any later version.
   12:  *
   13:  * This program is distributed in the hope that it will be useful,
   14:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   15:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   16:  * GNU General Public License for more details.
   17:  * 
   18:  * You should have received a copy of the GNU General Public License
   19:  * along with this program; if not, write to the Free Software
   20:  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   21:  *
   22:  */
   23: 
   24: #include "config-parser.h"
   25: #include <dbus/dbus-internals.h>
   26: #include <libxml/xmlreader.h>
   27: #include <libxml/parser.h>
   28: #include <libxml/globals.h>
   29: #include <libxml/xmlmemory.h>
   30: #include <errno.h>
   31: #include <string.h>
   32: 
   33: /* About the error handling: 
   34:  *  - setup a "structured" error handler that catches structural
   35:  *    errors and some oom errors 
   36:  *  - assume that a libxml function returning an error code means
   37:  *    out-of-memory
   38:  */
   39: #define _DBUS_MAYBE_SET_OOM(e) (dbus_error_is_set(e) ? (void)0 : _DBUS_SET_OOM(e))
   40: 
   41: 
   42: static dbus_bool_t
   43: xml_text_start_element (BusConfigParser   *parser,
   44:                         xmlTextReader     *reader,
   45:                         DBusError         *error)
   46: {
   47:   const char *name;
   48:   int n_attributes;
   49:   const char **attribute_names, **attribute_values;
   50:   dbus_bool_t ret;
   51:   int i, status, is_empty;
   52: 
   53:   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
   54: 
   55:   ret = FALSE;
   56:   attribute_names = NULL;
   57:   attribute_values = NULL;
   58: 
   59:   name = xmlTextReaderConstName (reader);
   60:   n_attributes = xmlTextReaderAttributeCount (reader);
   61:   is_empty = xmlTextReaderIsEmptyElement (reader);
   62: 
   63:   if (name == NULL || n_attributes < 0 || is_empty == -1)
   64:     {
   65:       _DBUS_MAYBE_SET_OOM (error);
   66:       goto out;
   67:     }
   68: 
   69:   attribute_names = dbus_new0 (const char *, n_attributes + 1);
   70:   attribute_values = dbus_new0 (const char *, n_attributes + 1);
   71:   if (attribute_names == NULL || attribute_values == NULL)
   72:     {
   73:       _DBUS_SET_OOM (error);
   74:       goto out;
   75:     }
   76:   i = 0;
   77:   while ((status = xmlTextReaderMoveToNextAttribute (reader)) == 1)
   78:     {
   79:       _dbus_assert (i < n_attributes);
   80:       attribute_names[i] = xmlTextReaderConstName (reader);
   81:       attribute_values[i] = xmlTextReaderConstValue (reader);
   82:       if (attribute_names[i] == NULL || attribute_values[i] == NULL)
   83:         { 
   84:           _DBUS_MAYBE_SET_OOM (error);
   85:           goto out;
   86:         }
   87:       i++;
   88:     }
   89:   if (status == -1)
   90:     {
   91:       _DBUS_MAYBE_SET_OOM (error);
   92:       goto out;
   93:     }
   94:   _dbus_assert (i == n_attributes);
   95: 
   96:   ret = bus_config_parser_start_element (parser, name,
   97:                                          attribute_names, attribute_values,
   98:                                          error);
   99:   if (ret && is_empty == 1)
  100:     ret = bus_config_parser_end_element (parser, name, error);
  101: 
  102:  out:
  103:   dbus_free (attribute_names);
  104:   dbus_free (attribute_values);
  105: 
  106:   return ret;
  107: }
  108: 
  109: static void xml_shut_up (void *ctx, const char *msg, ...)
  110: {
  111:     return;
  112: }
  113: 
  114: static void
  115: xml_text_reader_error (void *arg, xmlErrorPtr xml_error)
  116: {
  117:   DBusError *error = arg;
  118: 
  119: #if 0
  120:   _dbus_verbose ("XML_ERROR level=%d, domain=%d, code=%d, msg=%s\n",
  121:                  xml_error->level, xml_error->domain,
  122:                  xml_error->code, xml_error->message);
  123: #endif
  124: 
  125:   if (!dbus_error_is_set (error))
  126:     {
  127:       if (xml_error->code == XML_ERR_NO_MEMORY)
  128:         _DBUS_SET_OOM (error);
  129:       else if (xml_error->level == XML_ERR_ERROR ||
  130:                xml_error->level == XML_ERR_FATAL)
  131:         dbus_set_error (error, DBUS_ERROR_FAILED,
  132:                         "Error loading config file: '%s'",
  133:                         xml_error->message);
  134:     }
  135: }
  136: 
  137: 
  138: BusConfigParser*
  139: bus_config_load (const DBusString      *file,
  140:                  dbus_bool_t            is_toplevel,
  141:                  const BusConfigParser *parent,
  142:                  DBusError             *error)
  143: 
  144: {
  145:   xmlTextReader *reader;
  146:   BusConfigParser *parser;
  147:   DBusString dirname, data;
  148:   DBusError tmp_error;
  149:   int ret;
  150:   
  151:   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  152:   
  153:   parser = NULL;
  154:   reader = NULL;
  155: 
  156:   if (!_dbus_string_init (&dirname))
  157:     {
  158:       _DBUS_SET_OOM (error);
  159:       return NULL;
  160:     }
  161: 
  162:   if (!_dbus_string_init (&data))
  163:     {
  164:       _DBUS_SET_OOM (error);
  165:       _dbus_string_free (&dirname);
  166:       return NULL;
  167:     }
  168: 
  169:   if (is_toplevel)
  170:     {
  171:       /* xmlMemSetup only fails if one of the functions is NULL */
  172:       xmlMemSetup (dbus_free,
  173:                    dbus_malloc,
  174:                    dbus_realloc,
  175:                    _dbus_strdup);
  176:       xmlInitParser ();
  177:       xmlSetGenericErrorFunc (NULL, xml_shut_up);
  178:     }
  179: 
  180:   if (!_dbus_string_get_dirname (file, &dirname))
  181:     {
  182:       _DBUS_SET_OOM (error);
  183:       goto failed;
  184:     }
  185:   
  186:   parser = bus_config_parser_new (&dirname, is_toplevel, parent);
  187:   if (parser == NULL)
  188:     {
  189:       _DBUS_SET_OOM (error);
  190:       goto failed;
  191:     }
  192:   
  193:   if (!_dbus_file_get_contents (&data, file, error))
  194:     goto failed;
  195: 
  196:   reader = xmlReaderForMemory (_dbus_string_get_const_data (&data), 
  197:                                _dbus_string_get_length (&data),
  198:                                NULL, NULL, 0);
  199:   if (reader == NULL)
  200:     {
  201:       _DBUS_SET_OOM (error);
  202:       goto failed;
  203:     }
  204: 
  205:   xmlTextReaderSetParserProp (reader, XML_PARSER_SUBST_ENTITIES, 1);
  206: 
  207:   dbus_error_init (&tmp_error);
  208:   xmlTextReaderSetStructuredErrorHandler (reader, xml_text_reader_error, &tmp_error);
  209: 
  210:   while ((ret = xmlTextReaderRead (reader)) == 1)
  211:     {
  212:       int type;
  213:       
  214:       if (dbus_error_is_set (&tmp_error))
  215:         goto reader_out;
  216: 
  217:       type = xmlTextReaderNodeType (reader);
  218:       if (type == -1)
  219:         {
  220:           _DBUS_MAYBE_SET_OOM (&tmp_error);
  221:           goto reader_out;
  222:         }
  223: 
  224:       switch ((xmlReaderTypes) type) {
  225:       case XML_READER_TYPE_ELEMENT:
  226:         xml_text_start_element (parser, reader, &tmp_error);
  227:         break;
  228: 
  229:       case XML_READER_TYPE_TEXT:
  230:       case XML_READER_TYPE_CDATA:
  231:         {
  232:           DBusString content;
  233:           const char *value;
  234:           value = xmlTextReaderConstValue (reader);
  235:           if (value != NULL)
  236:             {
  237:               _dbus_string_init_const (&content, value);
  238:               bus_config_parser_content (parser, &content, &tmp_error);
  239:             }
  240:           else
  241:             _DBUS_MAYBE_SET_OOM (&tmp_error);
  242:           break;
  243:         }
  244: 
  245:       case XML_READER_TYPE_DOCUMENT_TYPE:
  246:         {
  247:           const char *name;
  248:           name = xmlTextReaderConstName (reader);
  249:           if (name != NULL)
  250:             bus_config_parser_check_doctype (parser, name, &tmp_error);
  251:           else
  252:             _DBUS_MAYBE_SET_OOM (&tmp_error);
  253:           break;
  254:         }
  255: 
  256:       case XML_READER_TYPE_END_ELEMENT:
  257:         {
  258:           const char *name;
  259:           name = xmlTextReaderConstName (reader);
  260:           if (name != NULL)
  261:             bus_config_parser_end_element (parser, name, &tmp_error);
  262:           else
  263:             _DBUS_MAYBE_SET_OOM (&tmp_error);
  264:           break;
  265:         }
  266: 
  267:       case XML_READER_TYPE_DOCUMENT:
  268:       case XML_READER_TYPE_DOCUMENT_FRAGMENT:
  269:       case XML_READER_TYPE_PROCESSING_INSTRUCTION:
  270:       case XML_READER_TYPE_COMMENT:
  271:       case XML_READER_TYPE_ENTITY:
  272:       case XML_READER_TYPE_NOTATION:
  273:       case XML_READER_TYPE_WHITESPACE:
  274:       case XML_READER_TYPE_SIGNIFICANT_WHITESPACE:
  275:       case XML_READER_TYPE_END_ENTITY:
  276:       case XML_READER_TYPE_XML_DECLARATION:
  277:         /* nothing to do, just read on */
  278:         break;
  279: 
  280:       case XML_READER_TYPE_NONE:
  281:       case XML_READER_TYPE_ATTRIBUTE:
  282:       case XML_READER_TYPE_ENTITY_REFERENCE:
  283:         _dbus_assert_not_reached ("unexpected nodes in XML");
  284:       }
  285: 
  286:       if (dbus_error_is_set (&tmp_error))
  287:         goto reader_out;
  288:     }
  289: 
  290:   if (ret == -1)
  291:     _DBUS_MAYBE_SET_OOM (&tmp_error);
  292: 
  293:  reader_out:
  294:   xmlFreeTextReader (reader);
  295:   reader = NULL;
  296:   if (dbus_error_is_set (&tmp_error))
  297:     {
  298:       dbus_move_error (&tmp_error, error);
  299:       goto failed;
  300:     }
  301:   
  302:   if (!bus_config_parser_finished (parser, error))
  303:     goto failed;
  304:   _dbus_string_free (&dirname);
  305:   _dbus_string_free (&data);
  306:   if (is_toplevel)
  307:     xmlCleanupParser();
  308:   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  309:   return parser;
  310:   
  311:  failed:
  312:   _DBUS_ASSERT_ERROR_IS_SET (error);
  313:   _dbus_string_free (&dirname);
  314:   _dbus_string_free (&data);
  315:   if (is_toplevel)
  316:     xmlCleanupParser();
  317:   if (parser)
  318:     bus_config_parser_unref (parser);
  319:   _dbus_assert (reader == NULL); /* must go to reader_out first */
  320:   return NULL;
  321: }