/*
| Copyright (C) 2008 Christophe Fergeau <teuf@gnome.org>
| Part of the gtkpod project.
|
| URL: http://www.gtkpod.org/
| URL: http://gtkpod.sourceforge.net/
|
| The code contained in this file is free software; you can redistribute
| it and/or modify it under the terms of the GNU Lesser General Public
| License as published by the Free Software Foundation; either version
| 2.1 of the License, or (at your option) any later version.
|
| This file 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
| Lesser General Public License for more details.
|
| You should have received a copy of the GNU Lesser General Public
| License along with this code; if not, write to the Free Software
| Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
| iTunes and iPod are trademarks of Apple
|
| This product is not supported/written/published by Apple!
|
| $Id$
*/
/* This file implements a generic plist parser. A plist file is an
* Apple-specific XML format which is used to serialize (simple) data
* structures to disk, see http://en.wikipedia.org/wiki/Property_list
*
* This parser should handle most plist files, with those limitations :
* - no support for <date> tags
*
* The plist file is parsed using libxml, and the parsed result is stored
* in GValue. The types are mapped in the following way:
* - <string> => G_TYPE_STRING (char*)
* - <real> => G_TYPE_DOUBLE (double)
* - <integer> => G_TYPE_INT64 (gint64)
* - <true/>, <false/> => G_TYPE_BOOLEAN (gboolean)
* - <data> => G_TYPE_GSTRING (GString *)
* - <array> => G_TYPE_ARRAY (GArray *)
* - <dict> => G_TYPE_HASH_TABLE (GHashTable *)
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#ifdef HAVE_LIBXML
#include <stdio.h>
#include <string.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
#include <glib.h>
#include <glib-object.h>
#include "itdb_plist.h"
#ifdef DEBUG_SYSINFO_PARSING
#define DEBUG g_print
#else
#define DEBUG(...)
#endif
/* Error domain */
#define ITDB_DEVICE_ERROR itdb_device_error_quark ()
extern GQuark itdb_device_error_quark (void);
static GValue *parse_node (xmlNode *a_node, GError **error);
static void
value_free (GValue *val)
{
g_value_unset (val);
g_free (val);
}
static GValue *
parse_integer(xmlNode *a_node, GError **error)
{
char *str_val;
char *end_ptr;
gint64 int_val;
GValue *value;
str_val = (char *)xmlNodeGetContent(a_node);
int_val = strtoll (str_val, &end_ptr, 0);
if (*end_ptr != '\0') {
g_set_error (error, ITDB_DEVICE_ERROR, ITDB_DEVICE_ERROR_XML_PARSING,
"invalid integer value: %s", str_val);
xmlFree (str_val);
return NULL;
}
xmlFree (str_val);
value = g_new0(GValue, 1);
g_value_init(value, G_TYPE_INT64);
g_value_set_int64 (value, int_val);
return value;
}
static GValue *
parse_string(xmlNode *a_node, G_GNUC_UNUSED GError **error)
{
char *str_val;
GValue *value;
str_val = (char *)xmlNodeGetContent(a_node);
value = g_new0(GValue, 1);
g_value_init(value, G_TYPE_STRING);
g_value_set_string (value, str_val);
xmlFree (str_val);
return value;
}
static GValue *
parse_real(xmlNode *a_node, GError **error)
{
char *str_val;
char *end_ptr;
gfloat double_val;
GValue *value;
str_val = (char *)xmlNodeGetContent(a_node);
double_val = g_ascii_strtod (str_val, &end_ptr);
if (*end_ptr != '\0') {
g_set_error (error, ITDB_DEVICE_ERROR, ITDB_DEVICE_ERROR_XML_PARSING,
"invalid real value: %s", str_val);
xmlFree (str_val);
return NULL;
}
xmlFree (str_val);
value = g_new0(GValue, 1);
g_value_init(value, G_TYPE_DOUBLE);
g_value_set_double (value, double_val);
return value;
}
static GValue *
parse_boolean (xmlNode *a_node, GError **error)
{
gboolean bool_val;
GValue *value;
if (strcmp ((char *)a_node->name, "true") == 0) {
bool_val = TRUE;
} else if (strcmp ((char *)a_node->name, "false") == 0) {
bool_val = FALSE;
} else {
g_set_error (error, ITDB_DEVICE_ERROR, ITDB_DEVICE_ERROR_XML_PARSING,
"unexpected boolean value: %s", a_node->name);
return NULL;
}
value = g_new0 (GValue, 1);
g_value_init (value, G_TYPE_BOOLEAN);
g_value_set_boolean (value, bool_val);
return value;
}
static GValue *
parse_data (xmlNode *a_node, G_GNUC_UNUSED GError **error)
{
char *str_val;
guchar *raw_data;
gsize len;
GString *data_val;
GValue *value;
str_val = (char *)xmlNodeGetContent(a_node);
#if GLIB_CHECK_VERSION(2,12,0)
/* base64 support only after GLib 2.12 */
raw_data = g_base64_decode (str_val, &len);
#else
#warning GLib > 2.12 required for g_base64_decode(). Working around this problem.
raw_data = g_strdup ("");
len = 0;
#endif
xmlFree (str_val);
data_val = g_string_new_len ((char *)raw_data, len);
g_free (raw_data);
value = g_new0(GValue, 1);
g_value_init(value, G_TYPE_GSTRING);
g_value_take_boxed (value, data_val);
return value;
}
static xmlNode *
parse_one_dict_entry (xmlNode *a_node, GHashTable *dict, GError **error)
{
xmlNode *cur_node = a_node;
xmlChar *key_name;
GValue *value;
while ((cur_node != NULL) && (xmlStrcmp(cur_node->name, (xmlChar *)"key") != 0)) {
if (!xmlIsBlankNode (cur_node)) {
DEBUG ("skipping %s\n", cur_node->name);
}
cur_node = cur_node->next;
}
if (cur_node == NULL) {
g_set_error (error, ITDB_DEVICE_ERROR, ITDB_DEVICE_ERROR_XML_PARSING,
"Dict entry contains no <key> node");
return NULL;
}
key_name = xmlNodeGetContent (cur_node);
cur_node = cur_node->next;
while ((cur_node != NULL) && xmlIsBlankNode (cur_node)) {
cur_node = cur_node->next;
}
if (cur_node == NULL) {
g_set_error (error, ITDB_DEVICE_ERROR, ITDB_DEVICE_ERROR_XML_PARSING,
"<key> %s with no corresponding value node", key_name);
xmlFree (key_name);
return NULL;
}
value = parse_node (cur_node, error);
if (value != NULL) {
g_hash_table_insert (dict, g_strdup ((char *)key_name), value);
} else {
g_warning ("Couldn't parse value for %s: %s",
key_name, (*error)->message);
g_clear_error (error);
}
xmlFree (key_name);
return cur_node->next;
}
static GValue *
parse_dict (xmlNode *a_node, GError **error)
{
xmlNode *cur_node = a_node->children;
GValue *value;
GHashTable *dict;
dict = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, (GDestroyNotify)value_free);
while (cur_node != NULL) {
if (xmlIsBlankNode (cur_node)) {
cur_node = cur_node->next;
} else {
cur_node = parse_one_dict_entry (cur_node, dict, error);
}
}
if ((error != NULL) && (*error != NULL)) {
g_hash_table_destroy (dict);
return NULL;
}
value = g_new0 (GValue, 1);
value = g_value_init (value, G_TYPE_HASH_TABLE);
g_value_take_boxed (value, dict);
return value;
}
typedef GValue *(*ParseCallback) (xmlNode *, GError **);
static ParseCallback get_parser_for_type (const xmlChar *type);
static GValue *
parse_array (xmlNode *a_node, GError **error)
{
xmlNode *cur_node = a_node->children;
GValue *value;
GArray *array;
array = g_array_new (FALSE, TRUE, sizeof(GValue));
g_array_set_clear_func (array, (GDestroyNotify)g_value_unset);
while (cur_node != NULL) {
if (get_parser_for_type (cur_node->name) != NULL) {
GValue *cur_value;
cur_value = parse_node (cur_node, error);
if (cur_value != NULL) {
array = g_array_append_vals (array, cur_value, 1);
g_free (cur_value);
}
}
/* When an array contains an element enclosed in "unknown" tags (ie
* non-type ones), we silently skip them since early
* SysInfoExtended files used to have <key> values enclosed within
* <array> tags.
*/
cur_node = cur_node->next;
}
if ((error != NULL) && (*error != NULL)) {
g_array_unref (array);
return NULL;
}
value = g_new0 (GValue, 1);
value = g_value_init (value, G_TYPE_ARRAY);
g_value_take_boxed (value, array);
return value;
}
struct Parser {
const char * const type_name;
ParseCallback parser;
};
static const struct Parser parsers[] = { {"integer", parse_integer},
{"real", parse_real},
{"string", parse_string},
{"true", parse_boolean},
{"false", parse_boolean},
{"data", parse_data},
{"dict", parse_dict},
{"array", parse_array},
{NULL, NULL} };
static ParseCallback get_parser_for_type (const xmlChar *type)
{
guint i = 0;
while (parsers[i].type_name != NULL) {
if (xmlStrcmp (type, (xmlChar *)parsers[i].type_name) == 0) {
if (parsers[i].parser != NULL) {
return parsers[i].parser;
}
}
i++;
}
return NULL;
}
static GValue *parse_node (xmlNode *a_node, GError **error)
{
ParseCallback parser;
g_return_val_if_fail (a_node != NULL, NULL);
parser = get_parser_for_type (a_node->name);
if (parser != NULL) {
return parser (a_node, error);
} else {
DEBUG ("no parser for <%s>\n", a_node->name);
return NULL;
}
}
static GValue *
itdb_plist_parse (xmlNode * a_node, GError **error)
{
xmlNode *cur_node;
if (a_node == NULL) {
g_set_error (error, ITDB_DEVICE_ERROR, ITDB_DEVICE_ERROR_XML_PARSING,
"Empty XML document");
return NULL;
}
if (xmlStrcmp (a_node->name, (xmlChar *)"plist") != 0) {
g_set_error (error, ITDB_DEVICE_ERROR, ITDB_DEVICE_ERROR_XML_PARSING,
"XML document does not seem to be a plist document");
return NULL;
}
cur_node = a_node->xmlChildrenNode;
while ((cur_node != NULL) && (xmlIsBlankNode (cur_node))) {
cur_node = cur_node->next;
}
if (cur_node != NULL) {
return parse_node (cur_node, error);
}
g_set_error (error, ITDB_DEVICE_ERROR, ITDB_DEVICE_ERROR_XML_PARSING,
"Empty XML document");
return NULL;
}
/**
* itdb_plist_parse:
* @filename: name of the XML plist file to parse
* @error: return location for a #GError
*
* Parses the XML plist file stored in @filename. If an error occurs
* during the parsing, itdb_plist_parse will return NULL and @error
* will be set
*
* Returns: NULL on error (@error will be set), a newly allocated
* #GValue containing a #GHashTable otherwise.
*/
GValue *
itdb_plist_parse_from_file (const char *filename, GError **error)
{
xmlDoc *doc = NULL;
xmlNode *root_element = NULL;
GValue *parsed_doc;
doc = xmlReadFile(filename, NULL, 0);
if (doc == NULL) {
g_set_error (error, ITDB_DEVICE_ERROR, ITDB_DEVICE_ERROR_XML_PARSING,
"Error during XML parsing of file %s", filename);
return NULL;
}
root_element = xmlDocGetRootElement(doc);
parsed_doc = itdb_plist_parse (root_element, error);
xmlFreeDoc(doc);
return parsed_doc;
}
/**
* itdb_plist_parse_from_memory:
* @data: memory location containing XML plist data to parse
* @len: length in bytes of the string to parse
* @error: return location for a #GError
*
* Parses the XML plist file stored in @data which length is @len
* bytes. If an error occurs during the parsing,
* itdb_plist_parse_from_memory() will return NULL and @error will be
* set.
*
* Returns: NULL on error (@error will be set), a newly allocated
* #GValue containing a #GHashTable otherwise.
*/
GValue *
itdb_plist_parse_from_memory (const char *data, gsize len, GError **error)
{
xmlDoc *doc = NULL;
xmlNode *root_element = NULL;
GValue *parsed_doc;
doc = xmlReadMemory(data, len, "noname.xml", NULL, 0);
if (doc == NULL) {
g_set_error (error, ITDB_DEVICE_ERROR, ITDB_DEVICE_ERROR_XML_PARSING,
"Error during XML parsing of in-memory data");
return NULL;
}
root_element = xmlDocGetRootElement(doc);
parsed_doc = itdb_plist_parse (root_element, error);
xmlFreeDoc(doc);
return parsed_doc;
}
#else
#include <glib-object.h>
#include "itdb_plist.h"
GValue *itdb_plist_parse_from_file (G_GNUC_UNUSED const char *filename,
G_GNUC_UNUSED GError **error)
{
return NULL;
}
GValue *itdb_plist_parse_from_memory (G_GNUC_UNUSED const char *data,
G_GNUC_UNUSED gsize len,
G_GNUC_UNUSED GError **error)
{
return NULL;
}
#endif