extra-dependencies/debian/opensync/opensync-0.22/formats/vformats-xml/xml-vcal.c

/*
 * xml-vcard - A plugin for parsing vcard objects for the opensync framework
 * Copyright (C) 2004-2005  Armin Bauer <armin.bauer@opensync.org>
 * 
 * This library 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 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
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser 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
 * 
 */
 
#include "xml-support.h"
#include "vformat.h"
#include "vcalical.h"
#include "xml-vcal.h"
#include <glib.h>

/*TODO: replace all g_hash_table_insert by functions with well-defined-type parameters
 * (like insert_xml_attr_handler() and insert_attr_handler()) */

/*TODO: Refactor this and other xml-*.c code, to put all common code in the same place */

typedef xmlNode *(* vattr_handler_t)(xmlNode *, VFormatAttribute *);
typedef VFormatAttribute *(* xml_attr_handler_t)(VFormat *vcard, xmlNode *root, const char *encoding);

static void handle_unknown_parameter(xmlNode *current, VFormatParam *param)
{
	osync_trace(TRACE_INTERNAL, "Handling unknown parameter %s", vformat_attribute_param_get_name(param));
	xmlNode *property = xmlNewTextChild(current, NULL, (xmlChar*)"UnknownParam",
		(xmlChar*)vformat_attribute_param_get_nth_value(param, 0));
	osxml_node_add(property, "ParamName", vformat_attribute_param_get_name(param));
}

static void handle_tzid_parameter(xmlNode *current, VFormatParam *param)
{
	osync_trace(TRACE_INTERNAL, "Handling tzid parameter");
	xmlNewTextChild(current, NULL, (xmlChar*)"TimezoneID",
		(xmlChar*)vformat_attribute_param_get_nth_value(param, 0));
}

static void handle_value_parameter(xmlNode *current, VFormatParam *param)
{
	xmlNewTextChild(current, NULL, (xmlChar*)"Value",
		(xmlChar*)vformat_attribute_param_get_nth_value(param, 0));
}

static void handle_altrep_parameter(xmlNode *current, VFormatParam *param)
{
	xmlNewTextChild(current, NULL, (xmlChar*)"AlternateRep",
		(xmlChar*)vformat_attribute_param_get_nth_value(param, 0));
}

static void handle_cn_parameter(xmlNode *current, VFormatParam *param)
{
	xmlNewTextChild(current, NULL, (xmlChar*)"CommonName",
		(xmlChar*)vformat_attribute_param_get_nth_value(param, 0));
}

static void handle_delegated_from_parameter(xmlNode *current, VFormatParam *param)
{
	xmlNewTextChild(current, NULL, (xmlChar*)"DelegatedFrom",
		(xmlChar*)vformat_attribute_param_get_nth_value(param, 0));
}

static void handle_delegated_to_parameter(xmlNode *current, VFormatParam *param)
{
	xmlNewTextChild(current, NULL, (xmlChar*)"DelegatedTo",
		(xmlChar*)vformat_attribute_param_get_nth_value(param, 0));
}

static void handle_dir_parameter(xmlNode *current, VFormatParam *param)
{
	xmlNewTextChild(current, NULL, (xmlChar*)"Directory",
		(xmlChar*)vformat_attribute_param_get_nth_value(param, 0));
}

static void handle_format_type_parameter(xmlNode *current, VFormatParam *param)
{
	xmlNewTextChild(current, NULL, (xmlChar*)"FormaType",
		(xmlChar*)vformat_attribute_param_get_nth_value(param, 0));
}

static void handle_fb_type_parameter(xmlNode *current, VFormatParam *param)
{
	xmlNewTextChild(current, NULL, (xmlChar*)"FreeBusyType",
		(xmlChar*)vformat_attribute_param_get_nth_value(param, 0));
}

static void handle_member_parameter(xmlNode *current, VFormatParam *param)
{
	xmlNewTextChild(current, NULL, (xmlChar*)"Member",
		(xmlChar*)vformat_attribute_param_get_nth_value(param, 0));
}

static void handle_partstat_parameter(xmlNode *current, VFormatParam *param)
{
	xmlNewTextChild(current, NULL, (xmlChar*)"PartStat",
		(xmlChar*)vformat_attribute_param_get_nth_value(param, 0));
}

static void handle_range_parameter(xmlNode *current, VFormatParam *param)
{
	xmlNewTextChild(current, NULL, (xmlChar*)"Range",
		(xmlChar*)vformat_attribute_param_get_nth_value(param, 0));
}

static void handle_related_parameter(xmlNode *current, VFormatParam *param)
{
	xmlNewTextChild(current, NULL, (xmlChar*)"Related",
		(xmlChar*)vformat_attribute_param_get_nth_value(param, 0));
}

static void handle_reltype_parameter(xmlNode *current, VFormatParam *param)
{
	xmlNewTextChild(current, NULL, (xmlChar*)"RelationType",
		(xmlChar*)vformat_attribute_param_get_nth_value(param, 0));
}

static void handle_role_parameter(xmlNode *current, VFormatParam *param)
{
	xmlNewTextChild(current, NULL, (xmlChar*)"Role",
		(xmlChar*)vformat_attribute_param_get_nth_value(param, 0));
}

static void handle_rsvp_parameter(xmlNode *current, VFormatParam *param)
{
	xmlNewTextChild(current, NULL, (xmlChar*)"RSVP",
		(xmlChar*)vformat_attribute_param_get_nth_value(param, 0));
}

static void handle_sent_by_parameter(xmlNode *current, VFormatParam *param)
{
	xmlNewTextChild(current, NULL, (xmlChar*)"SentBy",
		(xmlChar*)vformat_attribute_param_get_nth_value(param, 0));
}

static void handle_status_parameter(xmlNode *current, VFormatParam *param)
{
	xmlNewTextChild(current, NULL, (xmlChar*)"Status",
		(xmlChar*)vformat_attribute_param_get_nth_value(param, 0));
}

static xmlNode *handle_unknown_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling unknown attribute %s", vformat_attribute_get_name(attr));
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"UnknownNode", NULL);
	osxml_node_add(current, "NodeName", vformat_attribute_get_name(attr));
	GList *values = vformat_attribute_get_values_decoded(attr);
	for (; values; values = values->next) {
		GString *retstr = (GString *)values->data;
		g_assert(retstr);
		osxml_node_add(current, "Content", retstr->str);
	}
	return current;
}

static xmlNode *handle_prodid_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling prodid attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"ProductID", NULL);
	osxml_node_add(current, "Content", vformat_attribute_get_nth_value(attr, 0));
	return current;
}

static xmlNode *handle_method_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling method attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Method", NULL);
	osxml_node_add(current, "Content", vformat_attribute_get_nth_value(attr, 0));
	return current;
}

static xmlNode *handle_dtstamp_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling dtstamp attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"DateCalendarCreated", NULL);
	osxml_node_add(current, "Content", vformat_attribute_get_nth_value(attr, 0));
	return current;
}

static xmlNode *handle_percent_complete_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling percent complete attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"PercentComplete", NULL);
	osxml_node_add(current, "Content", vformat_attribute_get_nth_value(attr, 0));
	return current;
}

static xmlNode *handle_created_attribute(xmlNode *root, VFormatAttribute *attr)
{
	const char *tmp;
	char *timestamp;
	osync_trace(TRACE_INTERNAL, "Handling created attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"DateCreated", NULL);
	tmp = vformat_attribute_get_nth_value(attr, 0);
	timestamp = osync_time_timestamp(tmp);
	osxml_node_add(current, "Content", timestamp);
	g_free(timestamp);
	return current;
}

static xmlNode *handle_dtstart_attribute(xmlNode *root, VFormatAttribute *attr)
{
	const char *tmp;
	char *timestamp;
	osync_trace(TRACE_INTERNAL, "Handling dtstart attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"DateStarted", NULL);
	tmp = vformat_attribute_get_nth_value(attr, 0);
	timestamp = osync_time_timestamp(tmp);
	osxml_node_add(current, "Content", timestamp);
	g_free(timestamp);
	return current;
}

static xmlNode *handle_rrule_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling rrule attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"RecurrenceRule", NULL);

	GList *values = NULL; 
	osync_bool interval_isset = FALSE;
	GString *retstr = NULL;

	values = vformat_attribute_get_values_decoded(attr);

	for (; values; values = values->next) {
		retstr = (GString *)values->data;
		g_assert(retstr);
		osxml_node_add(current, "Rule", retstr->str);
		if (strstr(retstr->str, "INTERVAL"))
			interval_isset = TRUE;
	}

	if (!interval_isset)
		osxml_node_add(current, "Rule", "INTERVAL=1");

	return current;
}

static xmlNode *handle_vcal_rrule_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling rrule attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"RecurrenceRule", NULL);

	GList *values = NULL; 

	const char *rrule = vformat_attribute_get_nth_value(attr, 0);
	values = conv_vcal2ical_rrule(rrule);

	for (; values; values = values->next) {
		osxml_node_add(current, "Rule", (char *) values->data);
	}

	g_list_free(values);

	return current;
}

static xmlNode *handle_vcal_transp_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling transp attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Transparency", NULL);

	const char *transp = vformat_attribute_get_nth_value(attr, 0);

	if (atoi(transp) > 0)
		osxml_node_add(current, "Content", "OPAQUE");
	else
		osxml_node_add(current, "Content", "TRANSPARENT");


	return current;
}

static xmlNode *handle_aalarm_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling aalarm attribute");

	time_t started, alarm;
	char *dtstarted = NULL, *duration = NULL;
	xmlNode *dtstartNode = NULL, *sub = NULL;
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Alarm", NULL);

	osxml_node_add(current, "AlarmAction", "AUDIO");
	osxml_node_add(current, "AlarmDescription", vformat_attribute_get_nth_value(attr, 1));

	/*
	osxml_node_add(current, "AlarmDuration", vformat_attribute_get_nth_value(attr, 1));
	osxml_node_add(current, "AlarmRepeat", vformat_attribute_get_nth_value(attr, 2));
	*/

	sub = xmlNewTextChild(current, NULL, (xmlChar*) "AlarmTrigger", NULL);

	// get timestamp of DateStarted or DateDue (for todos)
	if ((dtstartNode = osxml_get_node(root, "DateDue"))) {
		dtstarted = osxml_find_node(dtstartNode, "Content");
	} else if (( dtstartNode = osxml_get_node(root, "DateStarted"))) {
		dtstarted = osxml_find_node(dtstartNode, "Content");
	}

	/* TODO: This breaks the case if a localtime stamp + tzid
	   get synced to a vcal. This means that the alarm duration
	   _CAN_ be wrong when dtstarted is localtime and alarm is not localtime.

	   FIXME */  

	if (dtstarted) {
		started = osync_time_vtime2unix(dtstarted, 0);
		g_free(dtstarted);

		alarm = osync_time_vtime2unix(vformat_attribute_get_nth_value(attr, 0), 0);

		// convert offset in seconds to alarm duration
		duration = osync_time_sec2alarmdu(alarm - started);
		osxml_node_add(sub, "Content", duration);
		osxml_node_add(sub, "Value", "DURATION");
		osxml_node_add(sub, "Related", "START");
		g_free(duration);


	/* This happens only if a todo has a AALARM without any DateDue and DateStarted field.
    	   (This was found on a old SE mobile phone and is illegal.) */ 
	} else {
		osxml_node_add(sub, "Content", vformat_attribute_get_nth_value(attr, 0));
		osxml_node_add(sub, "Value", "DATE-TIME");
	}

	return current;
}

static xmlNode *handle_dalarm_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling dalarm attribute");

	time_t started, alarm;
	char *dtstarted = NULL, *duration = NULL;
	xmlNode *dtstartNode = NULL, *sub = NULL;
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Alarm", NULL);

	osxml_node_add(current, "AlarmDescription", vformat_attribute_get_nth_value(attr, 1));
	/*
	osxml_node_add(current, "AlarmDuration", vformat_attribute_get_nth_value(attr, 1));
	osxml_node_add(current, "AlarmRepeat", vformat_attribute_get_nth_value(attr, 2));
	*/

	osxml_node_add(current, "AlarmAction", "DISPLAY");

	sub = xmlNewTextChild(current, NULL, (xmlChar*) "AlarmTrigger", NULL);

	// get timestamp of DateStarted or DateDue (for todos)
	if ((dtstartNode = osxml_get_node(root, "DateDue"))) {
		dtstarted = osxml_find_node(dtstartNode, "Content");
	} else if (( dtstartNode = osxml_get_node(root, "DateStarted"))) {
		dtstarted = osxml_find_node(dtstartNode, "Content");
	}

	/* TODO: This breaks the case if a localtime stamp + tzid
	   get synced to a vcal. This means that the alarm duration
	   _CAN_ be wrong when dtstarted is localtime and alarm is not localtime.

	   FIXME */  

	if (dtstarted) {
		started = osync_time_vtime2unix(dtstarted, 0);
		g_free(dtstarted);

		alarm = osync_time_vtime2unix(vformat_attribute_get_nth_value(attr, 0), 0);

		// convert offset in seconds to alarm duration
		duration = osync_time_sec2alarmdu(alarm - started);
		osxml_node_add(sub, "Content", duration);
		osxml_node_add(sub, "Value", "DURATION");
		osxml_node_add(sub, "Related", "START");
		g_free(duration);


	/* This happens only if a todo has a AALARM without any DateDue and DateStarted field.
    	   (This was found on a old SE mobile phone and is illegal.) */ 
	} else {
		osxml_node_add(sub, "Content", vformat_attribute_get_nth_value(attr, 0));
		osxml_node_add(sub, "Value", "DATE-TIME");
	}


	return current;
}

static xmlNode *handle_description_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling description attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Description", NULL);
	osxml_node_add(current, "Content", vformat_attribute_get_nth_value(attr, 0));
	return current;
}

static xmlNode *handle_summary_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling summary attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Summary", NULL);
	osxml_node_add(current, "Content", vformat_attribute_get_nth_value(attr, 0));
	return current;
}

static xmlNode *handle_categories_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling Categories attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Categories", NULL);
	
	GList *values = vformat_attribute_get_values_decoded(attr);
	for (; values; values = values->next) {
		GString *retstr = (GString *)values->data;
		g_assert(retstr);
		osxml_node_add(current, "Category", retstr->str);
	}
	
	return current;
}

static xmlNode *handle_class_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling Class attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Class", NULL);
	osxml_node_add(current, "Content", vformat_attribute_get_nth_value(attr, 0));
	return current;
}

static xmlNode *handle_due_attribute(xmlNode *root, VFormatAttribute *attr)
{
	const char *tmp;
	char *timestamp = NULL;
	osync_trace(TRACE_INTERNAL, "Handling due attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"DateDue", NULL);
	tmp = vformat_attribute_get_nth_value(attr, 0);
	timestamp = osync_time_timestamp(tmp);
	osxml_node_add(current, "Content", timestamp);
	g_free(timestamp);
	return current;
}

static xmlNode *handle_url_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling Url attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Url", NULL);
	osxml_node_add(current, "Content", vformat_attribute_get_nth_value(attr, 0));
	return current;
}

static xmlNode *handle_priority_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling priority attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Priority", NULL);
	osxml_node_add(current, "Content", vformat_attribute_get_nth_value(attr, 0));
	return current;
}

static xmlNode *handle_sequence_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling sequence attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Sequence", NULL);
	osxml_node_add(current, "Content", vformat_attribute_get_nth_value(attr, 0));
	return current;
}

static xmlNode *handle_last_modified_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling last_modified attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"LastModified", NULL);
	osxml_node_add(current, "Content", vformat_attribute_get_nth_value(attr, 0));
	return current;
}

static xmlNode *handle_rdate_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling last_modified attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"RecurrenceDate", NULL);
	osxml_node_add(current, "Content", vformat_attribute_get_nth_value(attr, 0));
	return current;
}

static xmlNode *handle_location_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling last_modified attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Location", NULL);
	osxml_node_add(current, "Content", vformat_attribute_get_nth_value(attr, 0));
	return current;
}

static xmlNode *handle_geo_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling geo attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Geo", NULL);
	osxml_node_add(current, "Latitude", vformat_attribute_get_nth_value(attr, 0));
	osxml_node_add(current, "Longitude", vformat_attribute_get_nth_value(attr, 1));
	return current;
}

static xmlNode *handle_completed_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling last_modified attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Completed", NULL);
	osxml_node_add(current, "Content", vformat_attribute_get_nth_value(attr, 0));
	return current;
}

static xmlNode *handle_organizer_attribute(xmlNode *root, VFormatAttribute *attr)
{
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Organizer", NULL);
	osxml_node_add(current, "Content", vformat_attribute_get_nth_value(attr, 0));
	return current;
}

static xmlNode *handle_recurid_attribute(xmlNode *root, VFormatAttribute *attr)
{
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"RecurrenceID", NULL);
	osxml_node_add(current, "Content", vformat_attribute_get_nth_value(attr, 0));
	return current;
}

static xmlNode *handle_status_attribute(xmlNode *root, VFormatAttribute *attr)
{
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Status", NULL);
	osxml_node_add(current, "Content", vformat_attribute_get_nth_value(attr, 0));
	return current;
}

static xmlNode *handle_duration_attribute(xmlNode *root, VFormatAttribute *attr)
{
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Duration", NULL);
	osxml_node_add(current, "Content", vformat_attribute_get_nth_value(attr, 0));
	return current;
}

static xmlNode *handle_attach_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling last_modified attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Attach", NULL);
	osxml_node_add(current, "Content", vformat_attribute_get_nth_value(attr, 0));
	return current;
}

static xmlNode *handle_attendee_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling last_modified attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Attendee", NULL);
	osxml_node_add(current, "Content", vformat_attribute_get_nth_value(attr, 0));
	return current;
}

static xmlNode *handle_contact_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling last_modified attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Contact", NULL);
	osxml_node_add(current, "Content", vformat_attribute_get_nth_value(attr, 0));
	return current;
}

static xmlNode *handle_exdate_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling last_modified attribute");
	xmlNode *current = NULL;
	char *datestamp = NULL;
	GList *values = vformat_attribute_get_values_decoded(attr);
	for (; values; values = values->next) {
		GString *retstr = (GString *)values->data;
		g_assert(retstr);
		current = xmlNewTextChild(root, NULL, (xmlChar*)"ExclusionDate", NULL);
		if (!osync_time_isdate(retstr->str)) {
			datestamp = osync_time_datestamp(retstr->str);
		} else {
			datestamp = g_strdup(retstr->str);
		}
		osxml_node_add(current, "Content", datestamp);

		if (!osync_time_isdate(retstr->str))
			osxml_node_add(current, "Value", "DATE");

		g_free(datestamp);
		g_string_free(retstr, TRUE);
	}

	return current;
}

static xmlNode *handle_exrule_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling last_modified attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"ExclusionRule", NULL);
	osxml_node_add(current, "Content", vformat_attribute_get_nth_value(attr, 0));
	return current;
}

static xmlNode *handle_rstatus_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling last_modified attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"RStatus", NULL);
	osxml_node_add(current, "Content", vformat_attribute_get_nth_value(attr, 0));
	return current;
}

static xmlNode *handle_related_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling last_modified attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Related", NULL);
	osxml_node_add(current, "Content", vformat_attribute_get_nth_value(attr, 0));
	return current;
}

static xmlNode *handle_resources_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling last_modified attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Resources", NULL);
	osxml_node_add(current, "Content", vformat_attribute_get_nth_value(attr, 0));
	return current;
}

static xmlNode *handle_dtend_attribute(xmlNode *root, VFormatAttribute *attr)
{
	char *timestamp;
	const char *tmp;
	osync_trace(TRACE_INTERNAL, "Handling last_modified attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"DateEnd", NULL);
	tmp = vformat_attribute_get_nth_value(attr, 0);
	timestamp = osync_time_timestamp(tmp);
	osxml_node_add(current, "Content", timestamp);
	g_free(timestamp);
	return current;
}

static xmlNode *handle_transp_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling last_modified attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Transparency", NULL);
	osxml_node_add(current, "Content", vformat_attribute_get_nth_value(attr, 0));
	return current;
}

static xmlNode *handle_calscale_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling last_modified attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"CalendarScale", NULL);
	osxml_node_add(current, "Content", vformat_attribute_get_nth_value(attr, 0));
	return current;
}

static xmlNode *handle_tzid_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling tzid attribute");
	return xmlNewTextChild(root, NULL, (xmlChar*)"TimezoneID",
		(xmlChar*)vformat_attribute_get_nth_value(attr, 0));
}

static xmlNode *handle_tz_location_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling tz location attribute");
	return xmlNewTextChild(root, NULL, (xmlChar*)"Location",
		(xmlChar*)vformat_attribute_get_nth_value(attr, 0));
}

static xmlNode *handle_tzoffsetfrom_location_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling tzoffsetfrom attribute");
	return xmlNewTextChild(root, NULL, (xmlChar*)"TZOffsetFrom",
		(xmlChar*)vformat_attribute_get_nth_value(attr, 0));
}

static xmlNode *handle_tzoffsetto_location_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling tzoffsetto attribute");
	return xmlNewTextChild(root, NULL, (xmlChar*)"TZOffsetTo",
		(xmlChar*)vformat_attribute_get_nth_value(attr, 0));
}

static xmlNode *handle_tzname_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling tzname attribute");
	return xmlNewTextChild(root, NULL, (xmlChar*)"TimezoneName",
		(xmlChar*)vformat_attribute_get_nth_value(attr, 0));
}

static xmlNode *handle_tzdtstart_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling tzdtstart attribute");
	return xmlNewTextChild(root, NULL, (xmlChar*)"DateStarted",
		(xmlChar*)vformat_attribute_get_nth_value(attr, 0));
}

static xmlNode *handle_tzrrule_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling tzrrule attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"RecurrenceRule", NULL);
	
	GList *values = vformat_attribute_get_values_decoded(attr);
	for (; values; values = values->next) {
		GString *retstr = (GString *)values->data;
		g_assert(retstr);
		osxml_node_add(current, "Rule", retstr->str);
	}
	
	return current;
}

static xmlNode *handle_tz_last_modified_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling tzdtstart attribute");
	return xmlNewTextChild(root, NULL, (xmlChar*)"LastModified",
		(xmlChar*)vformat_attribute_get_nth_value(attr, 0));
}

static xmlNode *handle_tzurl_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling tzdtstart attribute");
	return xmlNewTextChild(root, NULL, (xmlChar*)"TimezoneUrl",
		(xmlChar*)vformat_attribute_get_nth_value(attr, 0));
}

static xmlNode *handle_tzrdate_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling tzdtstart attribute");
	return xmlNewTextChild(root, NULL, (xmlChar*)"TimezoneDate",
		(xmlChar*)vformat_attribute_get_nth_value(attr, 0));
}

static xmlNode *handle_atrigger_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling tzdtstart attribute");
	xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"AlarmTrigger", NULL);
	osxml_node_add(current, "Content", vformat_attribute_get_nth_value(attr, 0));
	return current;
}

static xmlNode *handle_arepeat_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling tzdtstart attribute");
	return xmlNewTextChild(root, NULL, (xmlChar*)"AlarmRepeat",
		(xmlChar*)vformat_attribute_get_nth_value(attr, 0));
}

static xmlNode *handle_aduration_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling tzdtstart attribute");
	return xmlNewTextChild(root, NULL, (xmlChar*)"AlarmDuration",
		(xmlChar*)vformat_attribute_get_nth_value(attr, 0));
}

static xmlNode *handle_aaction_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling tzdtstart attribute");
	return xmlNewTextChild(root, NULL, (xmlChar*)"AlarmAction",
		(xmlChar*)vformat_attribute_get_nth_value(attr, 0));
}

static xmlNode *handle_aattach_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling tzdtstart attribute");
	return xmlNewTextChild(root, NULL, (xmlChar*)"AlarmAttach",
		(xmlChar*)vformat_attribute_get_nth_value(attr, 0));
}

static xmlNode *handle_adescription_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling tzdtstart attribute");
	return xmlNewTextChild(root, NULL, (xmlChar*)"AlarmDescription",
		(xmlChar*)vformat_attribute_get_nth_value(attr, 0));
}

static xmlNode *handle_aattendee_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling tzdtstart attribute");
	return xmlNewTextChild(root, NULL, (xmlChar*)"AlarmAttendee",
		(xmlChar*)vformat_attribute_get_nth_value(attr, 0));
}

static xmlNode *handle_asummary_attribute(xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_INTERNAL, "Handling tzdtstart attribute");
	return xmlNewTextChild(root, NULL, (xmlChar*)"AlarmSummary",
		(xmlChar*)vformat_attribute_get_nth_value(attr, 0));
}

static void vcard_handle_parameter(GHashTable *hooks, xmlNode *current, VFormatParam *param)
{
	osync_trace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, hooks, current, param);
	
	//Find the handler for this parameter
	void (* param_handler)(xmlNode *, VFormatParam *);
	char *paramname = g_strdup_printf("%s=%s", vformat_attribute_param_get_name(param), vformat_attribute_param_get_nth_value(param, 0));
	param_handler = g_hash_table_lookup(hooks, paramname);
	g_free(paramname);
	if (!param_handler)
		param_handler = g_hash_table_lookup(hooks, vformat_attribute_param_get_name(param));
	
	if (param_handler == HANDLE_IGNORE) {
		osync_trace(TRACE_EXIT, "%s: Ignored", __func__);
		return;
	}
	
	if (param_handler)
		param_handler(current, param);
	else
		handle_unknown_parameter(current, param);
	
	osync_trace(TRACE_EXIT, "%s", __func__);
}

static void vcal_handle_attribute(GHashTable *table, GHashTable *paramtable, xmlNode *root, VFormatAttribute *attr)
{
	osync_trace(TRACE_ENTRY, "%s(%p, %p, %p:%s)", __func__, table, root, attr, attr ? vformat_attribute_get_name(attr) : "None");
	xmlNode *current = NULL;
	
	//Dont add empty stuff
	GList *v;
	for (v = vformat_attribute_get_values(attr); v; v = v->next) {
		char *value = v->data;
		if (strlen(value) != 0)
			goto has_value;
	}
	osync_trace(TRACE_EXIT, "%s: No values", __func__);
	return;
	
has_value:;
	
	//We need to find the handler for this attribute
	vattr_handler_t attr_handler = g_hash_table_lookup(table, vformat_attribute_get_name(attr));
	osync_trace(TRACE_INTERNAL, "Hook is: %p", attr_handler);
	if (attr_handler == HANDLE_IGNORE) {
		osync_trace(TRACE_EXIT, "%s: Ignored", __func__);
		return;
	}
	if (attr_handler)
		current = attr_handler(root, attr);
	else
		current = handle_unknown_attribute(root, attr);

	//Handle all parameters of this attribute
	GList *params = vformat_attribute_get_params(attr);
	GList *p = NULL;
	for (p = params; p; p = p->next) {
		VFormatParam *param = p->data;
		vcard_handle_parameter(paramtable, current, param);
	}
	osync_trace(TRACE_EXIT, "%s", __func__);
}

static void vcal_parse_attributes(OSyncHooksTable *hooks, GHashTable *table, GHashTable *paramtable, GList **attributes, xmlNode *root)
{
	osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, attributes, root);
	
	GList *a = NULL;
	for (a = *attributes; a; a = a->next) {
		VFormatAttribute *attr = a->data;
		
		if (!strcmp(vformat_attribute_get_name(attr), "BEGIN")) {
			//Handling supcomponent
			a = a->next;
			if (!strcmp(vformat_attribute_get_nth_value(attr, 0), "VTIMEZONE")) {
				xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Timezone", NULL);
				vcal_parse_attributes(hooks, hooks->tztable, hooks->tztable, &a, current);
			} else if (!strcmp(vformat_attribute_get_nth_value(attr, 0), "DAYLIGHT")) {
				xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"DaylightSavings", NULL);
				vcal_parse_attributes(hooks, hooks->tztable, hooks->tztable, &a, current);
			} else if (!strcmp(vformat_attribute_get_nth_value(attr, 0), "STANDARD")) {
				xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Standard", NULL);
				vcal_parse_attributes(hooks, hooks->tztable, hooks->tztable, &a, current);
			} else if (!strcmp(vformat_attribute_get_nth_value(attr, 0), "VTODO")) {
				xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Todo", NULL);
				vcal_parse_attributes(hooks, hooks->comptable, hooks->compparamtable, &a, current);
			} else if (!strcmp(vformat_attribute_get_nth_value(attr, 0), "VEVENT")) {
				xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Event", NULL);
				vcal_parse_attributes(hooks, hooks->comptable, hooks->compparamtable, &a, current);
			} else if (!strcmp(vformat_attribute_get_nth_value(attr, 0), "VJOURNAL")) {
				xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Journal", NULL);
				vcal_parse_attributes(hooks, hooks->comptable, hooks->compparamtable, &a, current);
			} else if (!strcmp(vformat_attribute_get_nth_value(attr, 0), "VALARM")) {
				xmlNode *current = xmlNewTextChild(root, NULL, (xmlChar*)"Alarm", NULL);
				vcal_parse_attributes(hooks, hooks->alarmtable, hooks->alarmtable, &a, current);
			}
		} else if (!strcmp(vformat_attribute_get_name(attr), "END")) {
			osync_trace(TRACE_EXIT, "%s: Found END", __func__);
			*attributes = a;
			return;
		} else
			vcal_handle_attribute(table, paramtable, root, attr);
	}
	osync_trace(TRACE_EXIT, "%s: Done", __func__);
}

static osync_bool conv_vcal_to_xml(void *conv_data, char *input, int inpsize, char **output, int *outpsize, osync_bool *free_input, OSyncError **error)
{
	osync_trace(TRACE_ENTRY, "%s(%p, %p, %i, %p, %p, %p, %p)", __func__, conv_data, input, inpsize, output, outpsize, free_input, error);
	
	OSyncHooksTable *hooks = (OSyncHooksTable *)conv_data;
	
	osync_trace(TRACE_SENSITIVE, "Input vcal is:\n%s", input);
	
	/* The input is not null-terminated, but vformat_new_from_string() expects a null-terminated string */
	char *input_str = g_malloc(inpsize + 1);
	memcpy(input_str, input, inpsize);
	input_str[inpsize] = '\0';

	//Parse the vcard
	VFormat *vcal = vformat_new_from_string(input_str);
	g_free(input_str);
	
	osync_trace(TRACE_INTERNAL, "Creating xml doc");
	
	//Create a new xml document
	xmlDoc *doc = xmlNewDoc((xmlChar*)"1.0");
	xmlNode *root = osxml_node_add_root(doc, "vcal");
	
	osync_trace(TRACE_INTERNAL, "parsing attributes");
	
	//For every attribute we have call the handling hook
	GList *attributes = vformat_get_attributes(vcal);
	vcal_parse_attributes(hooks, hooks->table, hooks->table, &attributes, root);
	
	xmlChar *str = osxml_write_to_string(doc);
	osync_trace(TRACE_SENSITIVE, "Output XML is:\n%s", str);
	xmlFree(str);
	
	*free_input = TRUE;
	*output = (char *)doc;
	*outpsize = sizeof(doc);
	osync_trace(TRACE_EXIT, "%s: TRUE", __func__);
	return TRUE;
}

static osync_bool needs_encoding(const unsigned char *tmp, const char *encoding)
{
	int i = 0;
	if (!strcmp(encoding, "QUOTED-PRINTABLE")) {
		while (tmp[i] != 0) {
			if (tmp[i] > 127 || tmp[i] == 10 || tmp[i] == 13)
				return TRUE;
			i++;
		}
	} else {
		return !g_utf8_validate((gchar*)tmp, -1, NULL);
	}
	return FALSE;
}

static osync_bool needs_charset(const unsigned char *tmp)
{
	int i = 0;
	while (tmp[i] != 0) {
		if (tmp[i] > 127)
			return TRUE;
		i++;
	}
	return FALSE;
}

static void add_value(VFormatAttribute *attr, xmlNode *parent, const char *name, const char *encoding)
{
	char *tmp = NULL;
	if (!name)
		tmp = (char*)xmlNodeGetContent(parent);
	else
		tmp = osxml_find_node(parent, name);
	
	if (!tmp)
		return;
	
	if (needs_charset((unsigned char*)tmp))
		if (!vformat_attribute_has_param (attr, "CHARSET"))
			vformat_attribute_add_param_with_value(attr, "CHARSET", "UTF-8");
	
	if (encoding && needs_encoding((unsigned char*)tmp, encoding)) {
		if (!vformat_attribute_has_param (attr, "ENCODING"))
			vformat_attribute_add_param_with_value(attr, "ENCODING", encoding);
		vformat_attribute_add_value_decoded(attr, tmp, strlen(tmp) + 1);
	} else
		vformat_attribute_add_value(attr, tmp);
	g_free(tmp);
}

static void xml_handle_unknown_parameter(VFormatAttribute *attr, xmlNode *current)
{
	osync_trace(TRACE_INTERNAL, "Handling unknown xml parameter %s", current->name);
	char *content = (char*)xmlNodeGetContent(current);
	vformat_attribute_add_param_with_value(attr, (char*)current->name, content);
	g_free(content);
}

static void handle_xml_category_parameter(VFormatAttribute *attr, xmlNode *current)
{
	char *content = (char*)xmlNodeGetContent(current);
	vformat_attribute_add_value(attr, content);
	g_free(content);
}

static void handle_xml_rule_parameter(VFormatAttribute *attr, xmlNode *current)
{
	char *content = (char*)xmlNodeGetContent(current);
	vformat_attribute_add_value(attr, content);
	g_free(content);
}

static void handle_xml_value_parameter(VFormatAttribute *attr, xmlNode *current)
{
	char *content = (char*)xmlNodeGetContent(current);
	vformat_attribute_add_param_with_value(attr, "VALUE", content);
	g_free(content);
}

static void handle_xml_altrep_parameter(VFormatAttribute *attr, xmlNode *current)
{
	char *content = (char*)xmlNodeGetContent(current);
	vformat_attribute_add_param_with_value(attr, "ALTREP", content);
	g_free(content);
}

static void handle_xml_cn_parameter(VFormatAttribute *attr, xmlNode *current)
{
	char *content = (char*)xmlNodeGetContent(current);
	vformat_attribute_add_param_with_value(attr, "CN", content);
	g_free(content);
}

static void handle_xml_delegated_from_parameter(VFormatAttribute *attr, xmlNode *current)
{
	char *content = (char*)xmlNodeGetContent(current);
	vformat_attribute_add_param_with_value(attr, "DELEGATED-FROM", content);
	g_free(content);
}

static void handle_xml_delegated_to_parameter(VFormatAttribute *attr, xmlNode *current)
{
	char *content = (char*)xmlNodeGetContent(current);
	vformat_attribute_add_param_with_value(attr, "DELEGATED-TO", content);
	g_free(content);
}

static void handle_xml_dir_parameter(VFormatAttribute *attr, xmlNode *current)
{
	char *content = (char*)xmlNodeGetContent(current);
	vformat_attribute_add_param_with_value(attr, "DIR", content);
	g_free(content);
}

static void handle_xml_format_type_parameter(VFormatAttribute *attr, xmlNode *current)
{
	char *content = (char*)xmlNodeGetContent(current);
	vformat_attribute_add_param_with_value(attr, "FMTTYPE", content);
	g_free(content);
}

static void handle_xml_fb_type_parameter(VFormatAttribute *attr, xmlNode *current)
{
	char *content = (char*)xmlNodeGetContent(current);
	vformat_attribute_add_param_with_value(attr, "FBTYPE", content);
	g_free(content);
}

static void handle_xml_member_parameter(VFormatAttribute *attr, xmlNode *current)
{
	char *content = (char*)xmlNodeGetContent(current);
	vformat_attribute_add_param_with_value(attr, "MEMBER", content);
	g_free(content);
}

static void handle_xml_partstat_parameter(VFormatAttribute *attr, xmlNode *current)
{
	char *content = (char*)xmlNodeGetContent(current);
	vformat_attribute_add_param_with_value(attr, "PARTSTAT", content);
	g_free(content);
}

static void handle_xml_range_parameter(VFormatAttribute *attr, xmlNode *current)
{
	char *content = (char*)xmlNodeGetContent(current);
	vformat_attribute_add_param_with_value(attr, "RANGE", content);
	g_free(content);
}

static void handle_xml_reltype_parameter(VFormatAttribute *attr, xmlNode *current)
{
	char *content = (char*)xmlNodeGetContent(current);
	vformat_attribute_add_param_with_value(attr, "RELTYPE", content);
	g_free(content);
}

static void handle_xml_related_parameter(VFormatAttribute *attr, xmlNode *current)
{
	char *content = (char*)xmlNodeGetContent(current);
	vformat_attribute_add_param_with_value(attr, "RELATED", content);
	g_free(content);
}

static void handle_xml_role_parameter(VFormatAttribute *attr, xmlNode *current)
{
	char *content = (char*)xmlNodeGetContent(current);
	vformat_attribute_add_param_with_value(attr, "ROLE", content);
	g_free(content);
}

static void handle_xml_rsvp_parameter(VFormatAttribute *attr, xmlNode *current)
{
	char *content = (char*)xmlNodeGetContent(current);
	vformat_attribute_add_param_with_value(attr, "RSVP", content);
	g_free(content);
}

static void handle_xml_sent_by_parameter(VFormatAttribute *attr, xmlNode *current)
{
	char *content = (char*)xmlNodeGetContent(current);
	vformat_attribute_add_param_with_value(attr, "SENT-BY", content);
	g_free(content);
}

static VFormatAttribute *xml_handle_unknown_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	osync_trace(TRACE_INTERNAL, "Handling unknown xml attribute %s", root->name);
	char *name = osxml_find_node(root, "NodeName");
	VFormatAttribute *attr = vformat_attribute_new(NULL, name);
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_prodid_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	osync_trace(TRACE_INTERNAL, "Handling prodid xml attribute");
	VFormatAttribute *attr = vformat_attribute_new(NULL, "PRODID");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_method_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	osync_trace(TRACE_INTERNAL, "Handling method xml attribute");
	VFormatAttribute *attr = vformat_attribute_new(NULL, "METHOD");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_geo_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	osync_trace(TRACE_INTERNAL, "Handling location xml attribute");
	VFormatAttribute *attr = vformat_attribute_new(NULL, "GEO");
	add_value(attr, root, "Latitude", encoding);
	add_value(attr, root, "Longitude", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_url_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	osync_trace(TRACE_INTERNAL, "Handling url xml attribute");
	VFormatAttribute *attr = vformat_attribute_new(NULL, "URL");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_uid_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	osync_trace(TRACE_INTERNAL, "Handling uid xml attribute");
	VFormatAttribute *attr = vformat_attribute_new(NULL, "UID");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_class_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	osync_trace(TRACE_INTERNAL, "Handling class xml attribute");
	VFormatAttribute *attr = vformat_attribute_new(NULL, "CLASS");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_categories_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	osync_trace(TRACE_INTERNAL, "Handling categories xml attribute");
	VFormatAttribute *attr = vformat_attribute_new(NULL, "CATEGORIES");
	vformat_add_attribute(vcard, attr);
	return attr;
}

static void xml_vcard_handle_parameter(GHashTable *table, VFormatAttribute *attr, xmlNode *current)
{
	osync_trace(TRACE_ENTRY, "%s(%p, %p, %p:%s)", __func__, table, attr, current, current ? (char *)current->name : "None");
	
	//Find the handler for this parameter
	void (* xml_param_handler)(VFormatAttribute *attr, xmlNode *);
	char *content = (char*)xmlNodeGetContent(current);
	char *paramname = g_strdup_printf("%s=%s", current->name, content);
	g_free(content);
	xml_param_handler = g_hash_table_lookup(table, paramname);
	g_free(paramname);
	if (!xml_param_handler)
		xml_param_handler = g_hash_table_lookup(table, current->name);
	
	if (xml_param_handler == HANDLE_IGNORE) {
		osync_trace(TRACE_EXIT, "%s: Ignored", __func__);
		return;
	}
	
	if (xml_param_handler)
		xml_param_handler(attr, current);
	
	osync_trace(TRACE_EXIT, "%s", __func__);
}

static void xml_vcal_handle_attribute(GHashTable *table, VFormat *vcard, xmlNode *root)
{
	osync_trace(TRACE_ENTRY, "%s(%p, %p, %p:%s)", __func__, table, vcard, root, root ? (char *)root->name : "None");
	VFormatAttribute *attr = NULL;
	
	//We need to find the handler for this attribute
	xml_attr_handler_t xml_attr_handler = g_hash_table_lookup(table, root->name);
	osync_trace(TRACE_INTERNAL, "xml hook is: %p", xml_attr_handler);
	if (xml_attr_handler == HANDLE_IGNORE) {
		osync_trace(TRACE_EXIT, "%s: Ignored", __func__);
		return;
	}
	if (xml_attr_handler)
		/*FIXME: What the encoding parameter is supposed to be. Is it necessary? */
		attr = xml_attr_handler(vcard, root, NULL);
	else {
		osync_trace(TRACE_EXIT, "%s: Ignored2", __func__);
		return;
	}
	
	//Handle all parameters of this attribute
	xmlNode *child = root->xmlChildrenNode;
	while (child) {
		xml_vcard_handle_parameter(table, attr, child);
		child = child->next;
	}
	osync_trace(TRACE_EXIT, "%s", __func__);
}

static OSyncConvCmpResult compare_vevent(OSyncChange *leftchange, OSyncChange *rightchange)
{
	osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, leftchange, rightchange);
	
	OSyncXMLScore score[] =
	{
	{10, "/vcal/Event/StartTime"},
	{10, "/vcal/Event/EndTime"},
	{100, "/vcal/Event/Summary"},
	{0, "/vcal/Event/Uid"},
	{0, "/vcal/Event/Revision"},
	{0, "/vcal/Event/DateCalendarCreated"},
	{0, "/vcal/Event/DateCreated"},
	{0, "/vcal/Event/LastModified"},
	{0, "/vcal/Event/Sequence"},
	{0, "/vcal/Event/Class[Content = \"PUBLIC\"]"},
	{0, "/vcal/Event/Priority"},
	{0, "/vcal/Event/Transparency[Content = \"OPAQUE\"]"},
	{0, "/vcal/Method"},
//	{0, "/vcal/Timezone"},
	{0, NULL}
	};
	
	OSyncConvCmpResult ret = osxml_compare((xmlDoc*)osync_change_get_data(leftchange), (xmlDoc*)osync_change_get_data(rightchange), score, 0, 99);
	
	osync_trace(TRACE_EXIT, "%s: %i", __func__, ret);
	return ret;
}

static OSyncConvCmpResult compare_vtodo(OSyncChange *leftchange, OSyncChange *rightchange)
{
	osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, leftchange, rightchange);
	
	OSyncXMLScore score[] =
	{
	{100, "/vcal/Todo/Summary"},
	{0, "/vcal/Todo/Uid"},
	{0, "/vcal/Todo/Revision"},
	{0, "/vcal/Todo/DateCalendarCreated"},
	{0, "/vcal/Todo/DateCreated"},
	{0, "/vcal/Todo/LastModified"},
	{0, "/vcal/Todo/Sequence"},
	{0, "/vcal/Todo/Class[Content = \"PUBLIC\"]"},
	{0, "/vcal/Todo/Priority"},
	// ignore 'PercentComplete', because we aren't able to handle this at the moment
	{0, "/vcal/Todo/PercentComplete"},
	{0, "/vcal/Method"},
//	{0, "/vcal/Timezone"},
	{0, NULL}
	};
	
	OSyncConvCmpResult ret = osxml_compare((xmlDoc*)osync_change_get_data(leftchange), (xmlDoc*)osync_change_get_data(rightchange), score, 0, 99);
	
	osync_trace(TRACE_EXIT, "%s: %i", __func__, ret);
	return ret;
}

static char *print_vcal(OSyncChange *change)
{
	xmlDoc *doc = (xmlDoc *)osync_change_get_data(change);
	
	return (char *)osxml_write_to_string(doc);
}

static void destroy_xml(char *data, size_t size)
{
	xmlFreeDoc((xmlDoc *)data);
}

static void insert_attr_handler(GHashTable *table, const char *attrname, vattr_handler_t handler)
{
	g_hash_table_insert(table, (gpointer)attrname, handler);
}

static void *init_ical_to_xml(void)
{
	osync_trace(TRACE_ENTRY, "%s", __func__);
	OSyncHooksTable *hooks = g_malloc0(sizeof(OSyncHooksTable));
	
	hooks->table = g_hash_table_new(g_str_hash, g_str_equal);
	hooks->tztable = g_hash_table_new(g_str_hash, g_str_equal);
	hooks->comptable = g_hash_table_new(g_str_hash, g_str_equal);
	hooks->compparamtable = g_hash_table_new(g_str_hash, g_str_equal);
	hooks->alarmtable = g_hash_table_new(g_str_hash, g_str_equal);
	
	//todo attributes
	insert_attr_handler(hooks->comptable, "BEGIN", HANDLE_IGNORE);
	insert_attr_handler(hooks->comptable, "END", HANDLE_IGNORE);
	insert_attr_handler(hooks->comptable, "UID", HANDLE_IGNORE);	
	insert_attr_handler(hooks->comptable, "X-IRMC-LUID", HANDLE_IGNORE);
	insert_attr_handler(hooks->comptable, "X-SONYERICSSON-DST", HANDLE_IGNORE);
	insert_attr_handler(hooks->comptable, "DTSTAMP", handle_dtstamp_attribute);
	insert_attr_handler(hooks->comptable, "DESCRIPTION", handle_description_attribute);
	insert_attr_handler(hooks->comptable, "SUMMARY", handle_summary_attribute);
	insert_attr_handler(hooks->comptable, "DUE", handle_due_attribute);
	insert_attr_handler(hooks->comptable, "DTSTART", handle_dtstart_attribute);
	insert_attr_handler(hooks->comptable, "PERCENT-COMPLETE", handle_percent_complete_attribute);
	insert_attr_handler(hooks->comptable, "CLASS", handle_class_attribute);
	insert_attr_handler(hooks->comptable, "CATEGORIES", handle_categories_attribute);
	insert_attr_handler(hooks->comptable, "PRIORITY", handle_priority_attribute);
	insert_attr_handler(hooks->comptable, "URL", handle_url_attribute);
	insert_attr_handler(hooks->comptable, "SEQUENCE", handle_sequence_attribute);
	insert_attr_handler(hooks->comptable, "LAST-MODIFIED", handle_last_modified_attribute);
	insert_attr_handler(hooks->comptable, "CREATED", handle_created_attribute);
	insert_attr_handler(hooks->comptable, "DCREATED", handle_created_attribute);
	insert_attr_handler(hooks->comptable, "RRULE", handle_rrule_attribute);

	insert_attr_handler(hooks->comptable, "RDATE", handle_rdate_attribute);
	insert_attr_handler(hooks->comptable, "LOCATION", handle_location_attribute);
	insert_attr_handler(hooks->comptable, "GEO", handle_geo_attribute);
	insert_attr_handler(hooks->comptable, "COMPLETED", handle_completed_attribute);
	insert_attr_handler(hooks->comptable, "ORGANIZER", handle_organizer_attribute);
	insert_attr_handler(hooks->comptable, "ORGANIZER", HANDLE_IGNORE);
	insert_attr_handler(hooks->comptable, "X-ORGANIZER", HANDLE_IGNORE);
	insert_attr_handler(hooks->comptable, "RECURRENCE-ID", handle_recurid_attribute);
	insert_attr_handler(hooks->comptable, "STATUS", handle_status_attribute);
	insert_attr_handler(hooks->comptable, "DURATION", handle_duration_attribute);
	insert_attr_handler(hooks->comptable, "ATTACH", handle_attach_attribute);
	insert_attr_handler(hooks->comptable, "ATTENDEE", handle_attendee_attribute);
	insert_attr_handler(hooks->comptable, "COMMENT", HANDLE_IGNORE);
	insert_attr_handler(hooks->comptable, "CONTACT", handle_contact_attribute);
	insert_attr_handler(hooks->comptable, "EXDATE", handle_exdate_attribute);
	insert_attr_handler(hooks->comptable, "EXRULE", handle_exrule_attribute);
	insert_attr_handler(hooks->comptable, "RSTATUS", handle_rstatus_attribute);
	insert_attr_handler(hooks->comptable, "RELATED-TO", handle_related_attribute);
	insert_attr_handler(hooks->comptable, "RESOURCES", handle_resources_attribute);
	insert_attr_handler(hooks->comptable, "DTEND", handle_dtend_attribute);
	insert_attr_handler(hooks->comptable, "TRANSP", handle_transp_attribute);
	insert_attr_handler(hooks->comptable, "X-LIC-ERROR", HANDLE_IGNORE);
	
	g_hash_table_insert(hooks->compparamtable, "TZID", handle_tzid_parameter);
	g_hash_table_insert(hooks->compparamtable, "VALUE", handle_value_parameter);
	g_hash_table_insert(hooks->compparamtable, "ALTREP", handle_altrep_parameter);
	g_hash_table_insert(hooks->compparamtable, "CN", handle_cn_parameter);
	g_hash_table_insert(hooks->compparamtable, "DELEGATED-FROM", handle_delegated_from_parameter);
	g_hash_table_insert(hooks->compparamtable, "DELEGATED-TO", handle_delegated_to_parameter);
	g_hash_table_insert(hooks->compparamtable, "DIR", handle_dir_parameter);
	g_hash_table_insert(hooks->compparamtable, "FMTTYPE", handle_format_type_parameter);
	g_hash_table_insert(hooks->compparamtable, "FBTYPE", handle_fb_type_parameter);
	g_hash_table_insert(hooks->compparamtable, "MEMBER", handle_member_parameter);
	g_hash_table_insert(hooks->compparamtable, "PARTSTAT", handle_partstat_parameter);
	g_hash_table_insert(hooks->compparamtable, "RANGE", handle_range_parameter);
	g_hash_table_insert(hooks->compparamtable, "RELATED", handle_related_parameter);
	g_hash_table_insert(hooks->compparamtable, "RELTYPE", handle_reltype_parameter);
	g_hash_table_insert(hooks->compparamtable, "ROLE", handle_role_parameter);
	g_hash_table_insert(hooks->compparamtable, "RSVP", handle_rsvp_parameter);
	g_hash_table_insert(hooks->compparamtable, "SENT-BY", handle_sent_by_parameter);
	g_hash_table_insert(hooks->compparamtable, "X-LIC-ERROR", HANDLE_IGNORE);
	g_hash_table_insert(hooks->compparamtable, "CHARSET", HANDLE_IGNORE);
	g_hash_table_insert(hooks->compparamtable, "STATUS", handle_status_parameter);

	//vcal attributes
	g_hash_table_insert(hooks->table, "PRODID", handle_prodid_attribute);
	g_hash_table_insert(hooks->table, "PRODID", HANDLE_IGNORE);
	g_hash_table_insert(hooks->table, "METHOD", handle_method_attribute);
	g_hash_table_insert(hooks->table, "VERSION", HANDLE_IGNORE);
	g_hash_table_insert(hooks->table, "ENCODING", HANDLE_IGNORE);
	g_hash_table_insert(hooks->table, "CHARSET", HANDLE_IGNORE);
	g_hash_table_insert(hooks->table, "BEGIN", HANDLE_IGNORE);
	g_hash_table_insert(hooks->table, "END", HANDLE_IGNORE);
	g_hash_table_insert(hooks->table, "CALSCALE", handle_calscale_attribute);
	g_hash_table_insert(hooks->table, "X-LIC-ERROR", HANDLE_IGNORE);
	
	//Timezone
	g_hash_table_insert(hooks->tztable, "TZID", handle_tzid_attribute);
	g_hash_table_insert(hooks->tztable, "X-LIC-LOCATION", handle_tz_location_attribute);
	g_hash_table_insert(hooks->tztable, "TZOFFSETFROM", handle_tzoffsetfrom_location_attribute);
	g_hash_table_insert(hooks->tztable, "TZOFFSETTO", handle_tzoffsetto_location_attribute);
	g_hash_table_insert(hooks->tztable, "TZNAME", handle_tzname_attribute);
	g_hash_table_insert(hooks->tztable, "DTSTART", handle_tzdtstart_attribute);
	g_hash_table_insert(hooks->tztable, "RRULE", handle_tzrrule_attribute);
	g_hash_table_insert(hooks->tztable, "LAST-MODIFIED", handle_tz_last_modified_attribute);
	g_hash_table_insert(hooks->tztable, "BEGIN", HANDLE_IGNORE);
	g_hash_table_insert(hooks->tztable, "END", HANDLE_IGNORE);
	g_hash_table_insert(hooks->tztable, "TZURL", handle_tzurl_attribute);
	g_hash_table_insert(hooks->tztable, "COMMENT", HANDLE_IGNORE);
	g_hash_table_insert(hooks->tztable, "RDATE", handle_tzrdate_attribute);

	/*FIXME: The functions below shoudn't be on tztable, but on another hash table */
	g_hash_table_insert(hooks->tztable, "VALUE", handle_value_parameter);
	g_hash_table_insert(hooks->tztable, "ALTREP", handle_altrep_parameter);
	g_hash_table_insert(hooks->tztable, "CN", handle_cn_parameter);
	g_hash_table_insert(hooks->tztable, "DELEGATED-FROM", handle_delegated_from_parameter);
	g_hash_table_insert(hooks->tztable, "DELEGATED-TO", handle_delegated_to_parameter);
	g_hash_table_insert(hooks->tztable, "DIR", handle_dir_parameter);
	g_hash_table_insert(hooks->tztable, "FMTTYPE", handle_format_type_parameter);
	g_hash_table_insert(hooks->tztable, "FBTYPE", handle_fb_type_parameter);
	g_hash_table_insert(hooks->tztable, "MEMBER", handle_member_parameter);
	g_hash_table_insert(hooks->tztable, "PARTSTAT", handle_partstat_parameter);
	g_hash_table_insert(hooks->tztable, "RANGE", handle_range_parameter);
	g_hash_table_insert(hooks->tztable, "RELATED", handle_related_parameter);
	g_hash_table_insert(hooks->tztable, "RELTYPE", handle_reltype_parameter);
	g_hash_table_insert(hooks->tztable, "ROLE", handle_role_parameter);
	g_hash_table_insert(hooks->tztable, "RSVP", handle_rsvp_parameter);
	g_hash_table_insert(hooks->tztable, "SENT-BY", handle_sent_by_parameter);
	g_hash_table_insert(hooks->tztable, "X-LIC-ERROR", HANDLE_IGNORE);
	
	//VAlarm component
	g_hash_table_insert(hooks->alarmtable, "TRIGGER", handle_atrigger_attribute);
	g_hash_table_insert(hooks->alarmtable, "REPEAT", handle_arepeat_attribute);
	g_hash_table_insert(hooks->alarmtable, "DURATION", handle_aduration_attribute);
	g_hash_table_insert(hooks->alarmtable, "ACTION", handle_aaction_attribute);
	g_hash_table_insert(hooks->alarmtable, "ATTACH", handle_aattach_attribute);
	g_hash_table_insert(hooks->alarmtable, "DESCRIPTION", handle_adescription_attribute);
	g_hash_table_insert(hooks->alarmtable, "ATTENDEE", handle_aattendee_attribute);
	g_hash_table_insert(hooks->alarmtable, "SUMMARY", handle_asummary_attribute);

	/*FIXME: The functions below shoudn't be on alarmtable, but on another hash table */
	g_hash_table_insert(hooks->alarmtable, "TZID", handle_tzid_parameter);
	g_hash_table_insert(hooks->alarmtable, "VALUE", handle_value_parameter);
	g_hash_table_insert(hooks->alarmtable, "ALTREP", handle_altrep_parameter);
	g_hash_table_insert(hooks->alarmtable, "CN", handle_cn_parameter);
	g_hash_table_insert(hooks->alarmtable, "DELEGATED-FROM", handle_delegated_from_parameter);
	g_hash_table_insert(hooks->alarmtable, "DELEGATED-TO", handle_delegated_to_parameter);
	g_hash_table_insert(hooks->alarmtable, "DIR", handle_dir_parameter);
	g_hash_table_insert(hooks->alarmtable, "FMTTYPE", handle_format_type_parameter);
	g_hash_table_insert(hooks->alarmtable, "FBTYPE", handle_fb_type_parameter);
	g_hash_table_insert(hooks->alarmtable, "MEMBER", handle_member_parameter);
	g_hash_table_insert(hooks->alarmtable, "PARTSTAT", handle_partstat_parameter);
	g_hash_table_insert(hooks->alarmtable, "RANGE", handle_range_parameter);
	g_hash_table_insert(hooks->alarmtable, "RELATED", handle_related_parameter);
	g_hash_table_insert(hooks->alarmtable, "RELTYPE", handle_reltype_parameter);
	g_hash_table_insert(hooks->alarmtable, "ROLE", handle_role_parameter);
	g_hash_table_insert(hooks->alarmtable, "RSVP", handle_rsvp_parameter);
	g_hash_table_insert(hooks->alarmtable, "SENT-BY", handle_sent_by_parameter);
	g_hash_table_insert(hooks->alarmtable, "X-LIC-ERROR", HANDLE_IGNORE);
	g_hash_table_insert(hooks->alarmtable, "X-EVOLUTION-ALARM-UID", HANDLE_IGNORE);
	
	osync_trace(TRACE_EXIT, "%s: %p", __func__, hooks);
	return (void *)hooks;
}

static void *init_vcal_to_xml(void)
{
	osync_trace(TRACE_ENTRY, "%s", __func__);
	OSyncHooksTable *hooks = (OSyncHooksTable *)init_ical_to_xml();
	
	//vcal (event10) only
	insert_attr_handler(hooks->comptable, "RRULE", handle_vcal_rrule_attribute);
	insert_attr_handler(hooks->comptable, "TRANSP", handle_vcal_transp_attribute);
	insert_attr_handler(hooks->comptable, "AALARM", handle_aalarm_attribute);
	insert_attr_handler(hooks->comptable, "DALARM", handle_dalarm_attribute);

	osync_trace(TRACE_EXIT, "%s: %p", __func__, hooks);
	return (void *)hooks;
}

static void fin_vcal_to_xml(void *data)
{
	OSyncHooksTable *hooks = (OSyncHooksTable *)data;
	g_hash_table_destroy(hooks->table);
	g_free(hooks);
}



/* xml to vcal */
static VFormatAttribute *handle_xml_dtstamp_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "DTSTAMP");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_description_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "DESCRIPTION");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_summary_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "SUMMARY");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

/* ical only */
static VFormatAttribute *handle_xml_due_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "DUE");
	add_value(attr, root, "Content", encoding);
	vformat_attribute_add_param_with_value(attr, "TZID", osxml_find_node(root, "TimezoneID"));
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_dtstart_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "DTSTART");
	add_value(attr, root, "Content", encoding);
	vformat_attribute_add_param_with_value(attr, "TZID", osxml_find_node(root, "TimezoneID"));
	vformat_add_attribute(vcard, attr);
	return attr;
}
/* end ical only */

/* vcal only */
static VFormatAttribute *handle_vcal_xml_due_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "DUE");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_vcal_xml_dtstart_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "DTSTART");
	
	char *content = NULL;
	GString *newdate = g_string_new("");

	content = osxml_find_node(root, "Content");
	newdate = g_string_append(newdate, content);

	if (osync_time_isdate(content)) {
		newdate = g_string_append(newdate, "T000000");
	}

	g_free(content);

	vformat_attribute_add_value(attr, newdate->str); 
	vformat_add_attribute(vcard, attr);

	g_string_free(newdate, TRUE);

	return attr;
}
/* end vcal only */

static VFormatAttribute *handle_xml_percent_complete_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "PERCENT-COMPLETE");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_priority_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "PRIORITY");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_sequence_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "SEQUENCE");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_last_modified_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "LAST-MODIFIED");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_created_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "CREATED");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_rrule_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "RRULE");
	vformat_add_attribute(vcard, attr);
	return attr;
}

/* vcal only */
static VFormatAttribute *handle_vcal_xml_rrule_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "RRULE");

	char *vcalrrule = NULL;
	GString *icalrrule = g_string_new("");
        xmlNode *child = root->xmlChildrenNode;
	while (child) {
		icalrrule = g_string_append(icalrrule, (char*)xmlNodeGetContent(child));
		if (child->next)
			icalrrule = g_string_append(icalrrule, ";"); 

		child = child->next;
	}

	vcalrrule = conv_ical2vcal_rrule(icalrrule->str);

	g_string_free(icalrrule, TRUE);

	vformat_attribute_add_value(attr, vcalrrule);

	vformat_add_attribute(vcard, attr);
	return attr;
}
/* end of vcal only */

static VFormatAttribute *handle_xml_rdate_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "RDATE");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_location_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "LOCATION");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_completed_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "COMPLETED");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_organizer_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "ORGANIZER");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_recurid_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "RECURRENCE-ID");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_status_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "STATUS");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_duration_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "DURATION");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_attach_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "ATTACH");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_attendee_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "ATTENDEE");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_contact_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "CONTACT");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_exdate_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "EXDATE");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

/* vcal only */
static VFormatAttribute *handle_vcal_xml_exdate_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{

	xmlNode *dtstartNode = NULL;
	char *dtstart = NULL, *timestamp = NULL, *origex = NULL;
	GString *exdate = g_string_new("");
	VFormatAttribute *attr = NULL;

	if (!(attr = vformat_find_attribute(vcard, "EXDATE")))
		attr = vformat_attribute_new(NULL, "EXDATE");

	origex = (char *) xmlNodeGetContent(root);

	exdate = g_string_append(exdate, origex);

	if (!strstr(origex, "T")) {
		dtstartNode = osxml_get_node(root->parent->parent, "DateStarted"); 
		osync_trace(TRACE_INTERNAL, "dtstartNode pointer: %p", dtstartNode);
		dtstart = osxml_find_node(dtstartNode, "Content");
		timestamp = strstr(dtstart, "T");
		osync_trace(TRACE_INTERNAL, "append timestamp: %s", timestamp);
		exdate = g_string_append(exdate, timestamp); 
		g_free(dtstart);
	}
	
	vformat_attribute_add_value(attr, exdate->str);

	g_string_free(exdate, TRUE);

	if (!vformat_find_attribute(vcard, "EXDATE"))
		vformat_add_attribute(vcard, attr);
	return attr;
}
/* end of vcal only */

static VFormatAttribute *handle_xml_exrule_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "EXRULE");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_rstatus_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "RSTATUS");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_related_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "RELATED-TO");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_resources_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "RESOURCES");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

/* ical only */
static VFormatAttribute *handle_xml_dtend_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "DTEND");
	add_value(attr, root, "Content", encoding);
	vformat_attribute_add_param_with_value(attr, "TZID", osxml_find_node(root, "TimezoneID"));
	vformat_add_attribute(vcard, attr);
	return attr;
}
/* end ical only */

/* vcal only */
static VFormatAttribute *handle_vcal_xml_dtend_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "DTEND");
	
	char *content_dtend = NULL; 
	GString *new_dtend = g_string_new("");

	content_dtend = osxml_find_node(root, "Content");
	new_dtend = g_string_append(new_dtend, content_dtend);


	/*
	 * if (DTEND->VALUE == DATE) ==> DTEND = DTEND-60sec + "T000000"
	 *
	 * e.g. (SE W880i): 20070313T000000Z -> 20070313T235900Z
	 *
	 * this works also for SE K750i, SE D750i
	 *
	 */
        if (osync_time_isdate(content_dtend)) {

		osync_trace(TRACE_INTERNAL, "DTEND (old): %s", content_dtend);               
	
		char *tmp1 = NULL, *tmp2 = NULL;
 
		/* append "T000000" */
		new_dtend = g_string_append(new_dtend, "T000000");

		time_t dtend_unixtime = osync_time_vtime2unix(content_dtend, 0);

		/* DTEND = DTEND - 60 sec */
		dtend_unixtime -= 60;
	
		tmp1 = osync_time_unix2vtime(&dtend_unixtime);
		tmp2 = osync_time_vtime2localtime(tmp1, 0);
		
		g_string_erase(new_dtend, 0, -1);
		g_string_append(new_dtend, tmp2);
		
		osync_trace(TRACE_INTERNAL, "DTEND (new): %s", tmp2);               
		
		g_free(tmp1);
		g_free(tmp2);

	}
	
	g_free(content_dtend);

	vformat_attribute_add_value(attr, new_dtend->str);
	vformat_add_attribute(vcard, attr);

	g_string_free(new_dtend, TRUE);

	return attr;
}

static VFormatAttribute *handle_vcal_xml_transp_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "TRANSP");

	char *val = osxml_find_node(root, "Content");

	// Default: TRANSPARENT
	int block = 0;

	if (!strcmp("OPAQUE", val))
		block = 1;

	g_free(val);

	char *transp = g_strdup_printf("%i", block);
	vformat_attribute_add_value(attr, transp);
	vformat_add_attribute(vcard, attr);
	g_free(transp);

	return attr;
}
/* end vcal only */

static VFormatAttribute *handle_xml_transp_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "TRANSP");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_calscale_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "CALSCALE");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_tzid_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "TZID");
	add_value(attr, root, NULL, encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_tz_location_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "X-LIC-LOCATION");
	add_value(attr, root, NULL, encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_tzoffsetfrom_location_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "TZOFFSETFROM");
	add_value(attr, root, NULL, encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_tzoffsetto_location_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "TZOFFSETTO");
	add_value(attr, root, NULL, encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_tzname_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "TZNAME");
	add_value(attr, root, NULL, encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_tzdtstart_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "DTSTART");
	add_value(attr, root, NULL, encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_tzrrule_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "RRULE");
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_tz_last_modified_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "LAST-MODIFIED");
	add_value(attr, root, NULL, encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_tzurl_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "TZURL");
	add_value(attr, root, NULL, encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_tzrdate_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "RDATE");
	add_value(attr, root, NULL, encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

/* vcal only */
static VFormatAttribute *handle_vcal_xml_alarm_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	osync_trace(TRACE_INTERNAL, "Handling reminder xml attribute");

	xmlNode *dtstart = NULL;
	xmlNode *trigger = osxml_get_node(root, "AlarmTrigger");
	char *action = NULL, *tmp = NULL, *value = NULL, *runtime = NULL;
	char *startvtime = NULL;
	time_t dtstarted;
	int duration;
	osync_bool isruntime = FALSE;

	VFormatAttribute *attr = vformat_attribute_new(NULL, "DALARM");

	dtstart = osxml_get_node(root->parent, "DateStarted"); 
	value = osxml_find_node(dtstart, "Value");

	if (value) {
		if (strstr(value, "DATE-TIME")) {
			isruntime = TRUE;
		}
	}

	startvtime = osxml_find_node(dtstart, "Content");

	/* Runtime */
	if (isruntime) {
		runtime = startvtime; 
	/* Duration */	
	} else {
		tmp = osxml_find_node(trigger, "Content");
		duration = osync_time_alarmdu2sec(tmp);
		g_free(tmp);

		tmp = osxml_find_node(dtstart, "Content");
		/* AlarmTrigger MUST be UTC (see rfc2445).
		   So there is an offset to UTC of 0 seconds. */
		if (osync_time_isutc(tmp))
			osync_trace(TRACE_INTERNAL, "WARNNING: timestamp is not UTC: %s", tmp);

		dtstarted = osync_time_vtime2unix(tmp, 0);

		g_free(tmp);

		dtstarted += duration;

		runtime = osync_time_unix2vtime(&dtstarted);
	}

	g_free(value);

	vformat_attribute_add_value(attr, runtime);
	
	add_value(attr, root, "AlarmDuration", encoding);
	add_value(attr, root, "AlarmRepeat", encoding);
	add_value(attr, root, "AlarmDescription", encoding);

	action = osxml_find_node(root, "AlarmAction");
	if (action) {
		if (!strcmp(action, "AUDIO")) {
			osync_trace(TRACE_INTERNAL, "Handling audo reminder xml attribute");

			attr = vformat_attribute_new(NULL, "AALARM");
			vformat_attribute_add_value(attr, runtime);
			add_value(attr, root, "AlarmDuration", encoding);
			add_value(attr, root, "AlarmRepeat", encoding);
			add_value(attr, root, "AlarmDescription", encoding);
		}
	}

	vformat_add_attribute(vcard, attr);
	g_free(action);
	g_free(runtime);

	return attr;
}
/* end of vcal only */

/* ical only */
static VFormatAttribute *handle_xml_atrigger_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "TRIGGER");
	add_value(attr, root, "Content", encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_arepeat_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "REPEAT");
	add_value(attr, root, NULL, encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_aduration_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "DURATION");
	add_value(attr, root, NULL, encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_aaction_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "ACTION");
	add_value(attr, root, NULL, encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_aattach_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "ATTACH");
	add_value(attr, root, NULL, encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_adescription_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "DESCRIPTION");
	add_value(attr, root, NULL, encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_aattendee_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "ATTENDEE");
	add_value(attr, root, NULL, encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}

static VFormatAttribute *handle_xml_asummary_attribute(VFormat *vcard, xmlNode *root, const char *encoding)
{
	VFormatAttribute *attr = vformat_attribute_new(NULL, "SUMMARY");
	add_value(attr, root, NULL, encoding);
	vformat_add_attribute(vcard, attr);
	return attr;
}
/* end of ical only */

void xml_parse_attribute(OSyncHooksTable *hooks, GHashTable *table, xmlNode **current, VFormat *vcal, VFormatType target)
{
	osync_trace(TRACE_INTERNAL, "parsing xml attributes");
	void *xml_param_handler = NULL;
	VFormatAttribute *attr = NULL;
	xmlNode *root = *current;
	while (root) {
		if (!strcmp((char*)root->name, "Todo")) {
			attr = vformat_attribute_new(NULL, "BEGIN");
			vformat_attribute_add_value(attr, "VTODO");
			vformat_add_attribute(vcal, attr);
			xmlNode *child = root->children;
			xml_parse_attribute(hooks, hooks->comptable, &child, vcal, target);
			attr = vformat_attribute_new(NULL, "END");
			vformat_attribute_add_value(attr, "VTODO");
			vformat_add_attribute(vcal, attr);
		} else if (!strcmp((char*)root->name, "Timezone") && target != VFORMAT_EVENT_10) {
			attr = vformat_attribute_new(NULL, "BEGIN");
			vformat_attribute_add_value(attr, "VTIMEZONE");
			vformat_add_attribute(vcal, attr);
			xmlNode *child = root->children;
			xml_parse_attribute(hooks, hooks->tztable, &child, vcal, target);
			attr = vformat_attribute_new(NULL, "END");
			vformat_attribute_add_value(attr, "VTIMEZONE");
			vformat_add_attribute(vcal, attr);
		} else if (!strcmp((char*)root->name, "Event")) {
			attr = vformat_attribute_new(NULL, "BEGIN");
			vformat_attribute_add_value(attr, "VEVENT");
			vformat_add_attribute(vcal, attr);
			xmlNode *child = root->children;
			xml_parse_attribute(hooks, hooks->comptable, &child, vcal, target);
			attr = vformat_attribute_new(NULL, "END");
			vformat_attribute_add_value(attr, "VEVENT");
			vformat_add_attribute(vcal, attr);
		} else if (!strcmp((char*)root->name, "Journal")) {
			attr = vformat_attribute_new(NULL, "BEGIN");
			vformat_attribute_add_value(attr, "VJOURNAL");
			vformat_add_attribute(vcal, attr);
			xmlNode *child = root->children;
			xml_parse_attribute(hooks, hooks->tztable, &child, vcal, target);
			attr = vformat_attribute_new(NULL, "END");
			vformat_attribute_add_value(attr, "VJOURNAL");
			vformat_add_attribute(vcal, attr);
		} else if (!strcmp((char*)root->name, "DaylightSavings")) {
			attr = vformat_attribute_new(NULL, "BEGIN");
			vformat_attribute_add_value(attr, "DAYLIGHT");
			vformat_add_attribute(vcal, attr);
			xmlNode *child = root->children;
			xml_parse_attribute(hooks, hooks->tztable, &child, vcal, target);
			attr = vformat_attribute_new(NULL, "END");
			vformat_attribute_add_value(attr, "DAYLIGHT");
			vformat_add_attribute(vcal, attr);
		} else if (!strcmp((char*)root->name, "Standard")) {
			attr = vformat_attribute_new(NULL, "BEGIN");
			vformat_attribute_add_value(attr, "STANDARD");
			vformat_add_attribute(vcal, attr);
			xmlNode *child = root->children;
			xml_parse_attribute(hooks, hooks->tztable, &child, vcal, target);
			attr = vformat_attribute_new(NULL, "END");
			vformat_attribute_add_value(attr, "STANDARD");
			vformat_add_attribute(vcal, attr);
		} else if (!strcmp((char*)root->name, "Alarm") && target != VFORMAT_EVENT_10) {

				xmlNode *child = root->children;
				attr = vformat_attribute_new(NULL, "BEGIN");
				vformat_attribute_add_value(attr, "VALARM");
				vformat_add_attribute(vcal, attr);
				xml_parse_attribute(hooks, hooks->alarmtable, &child, vcal, target);
				attr = vformat_attribute_new(NULL, "END");
				vformat_attribute_add_value(attr, "VALARM");
				vformat_add_attribute(vcal, attr);

		/* list of parameters which should NOT handle for vcal (event10) */
		} else if (!strcmp((char*)root->name, "ExclusionDate") && target == VFORMAT_EVENT_10) {
				xml_param_handler = g_hash_table_lookup(hooks->comptable, "Value");
				g_hash_table_insert(hooks->comptable, "Value", HANDLE_IGNORE);
				g_hash_table_insert(hooks->comptable, "Content", handle_vcal_xml_exdate_attribute); 

				xmlNode *child = root->children;
				xml_parse_attribute(hooks, hooks->comptable, &child, vcal, target);

				g_hash_table_insert(hooks->comptable, "Value", xml_param_handler);
				g_hash_table_remove(hooks->comptable, "Content"); 

		} else {
			xml_vcal_handle_attribute(table, vcal, root);
		}
		root = root->next;
	}
}


static void insert_xml_attr_handler(GHashTable *table, const char *name, xml_attr_handler_t handler)
{
	g_hash_table_insert(table, (gpointer)name, handler);
}

static osync_bool conv_xml_to_vcal(void *user_data, char *input, int inpsize, char **output, int *outpsize, osync_bool *free_input, OSyncError **error, VFormatType target)
{
	osync_trace(TRACE_ENTRY, "%s(%p, %p, %i, %p, %p, %p, %p)", __func__, user_data, input, inpsize, output, outpsize, free_input, error);
	
	xmlChar *str = osxml_write_to_string((xmlDoc *)input);
	osync_trace(TRACE_SENSITIVE, "Input XML is:\n%s", str);
	xmlFree(str);
	
	//Get the root node of the input document
	xmlNode *root = osxml_node_get_root((xmlDoc *)input, "vcal", error);
	if (!root) {
		osync_error_set(error, OSYNC_ERROR_GENERIC, "Unable to get root element of xml-contact");
		osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
		return FALSE;
	}
	
	//Make the new vcard
	VFormat *vcal = vformat_new();
	
	OSyncHooksTable *hooks = (OSyncHooksTable *)user_data;
	/*  vevent10 / vevent20  */
	if (target == VFORMAT_EVENT_10) {
		/* RRULE */
		insert_xml_attr_handler(hooks->comptable, "RecurrenceRule", handle_vcal_xml_rrule_attribute);
		insert_xml_attr_handler(hooks->comptable, "ExclusionDate", handle_vcal_xml_exdate_attribute);
		insert_xml_attr_handler(hooks->comptable, "Alarm", handle_vcal_xml_alarm_attribute);
		g_hash_table_insert(hooks->comptable, "Rule", HANDLE_IGNORE);

		/* TRANSP */
		insert_xml_attr_handler(hooks->comptable, "Transparency", handle_vcal_xml_transp_attribute);

		/* vcal attributes */
		insert_xml_attr_handler(hooks->comptable, "DateEnd", handle_vcal_xml_dtend_attribute);
		insert_xml_attr_handler(hooks->comptable, "DateDue", handle_vcal_xml_due_attribute);
		insert_xml_attr_handler(hooks->comptable, "DateStarted", handle_vcal_xml_dtstart_attribute);

		/* vcal parameter */
		g_hash_table_insert(hooks->comptable, "Value", HANDLE_IGNORE);


	} else {
		/* RRULE */
		insert_xml_attr_handler(hooks->comptable, "RecurrenceRule", handle_xml_rrule_attribute);
		insert_xml_attr_handler(hooks->comptable, "ExclusionDate", handle_xml_exdate_attribute);
		g_hash_table_insert(hooks->comptable, "Rule", handle_xml_rule_parameter);

		/* TRANSP */
		insert_xml_attr_handler(hooks->comptable, "Transparency", handle_xml_transp_attribute);

		/* ical attributes */
		g_hash_table_insert(hooks->table, "Method", handle_xml_method_attribute);
		insert_xml_attr_handler(hooks->comptable, "DateEnd", handle_xml_dtend_attribute);
		insert_xml_attr_handler(hooks->comptable, "DateDue", handle_xml_due_attribute);
		insert_xml_attr_handler(hooks->comptable, "DateStarted", handle_xml_dtstart_attribute);

		/* Timezone */
		g_hash_table_insert(hooks->tztable, "TimezoneID", handle_xml_tzid_attribute);
		g_hash_table_insert(hooks->tztable, "Location", handle_xml_tz_location_attribute);
		g_hash_table_insert(hooks->tztable, "TZOffsetFrom", handle_xml_tzoffsetfrom_location_attribute);
		g_hash_table_insert(hooks->tztable, "TZOffsetTo", handle_xml_tzoffsetto_location_attribute);
		g_hash_table_insert(hooks->tztable, "TimezoneName", handle_xml_tzname_attribute);
		g_hash_table_insert(hooks->tztable, "DateStarted", handle_xml_tzdtstart_attribute);
		g_hash_table_insert(hooks->tztable, "RecurrenceRule", handle_xml_tzrrule_attribute);
		g_hash_table_insert(hooks->tztable, "LastModified", handle_xml_tz_last_modified_attribute);
		g_hash_table_insert(hooks->tztable, "TimezoneUrl", handle_xml_tzurl_attribute);
		g_hash_table_insert(hooks->tztable, "RecurrenceDate", handle_xml_tzrdate_attribute);

		/* VAlarm component */
		g_hash_table_insert(hooks->alarmtable, "AlarmTrigger", handle_xml_atrigger_attribute);
		g_hash_table_insert(hooks->alarmtable, "AlarmRepeat", handle_xml_arepeat_attribute);
		g_hash_table_insert(hooks->alarmtable, "AlarmDuration", handle_xml_aduration_attribute);
		g_hash_table_insert(hooks->alarmtable, "AlarmAction", handle_xml_aaction_attribute);
		g_hash_table_insert(hooks->alarmtable, "AlarmAttach", handle_xml_aattach_attribute);
		g_hash_table_insert(hooks->alarmtable, "AlarmDescription", handle_xml_adescription_attribute);
		g_hash_table_insert(hooks->alarmtable, "AlarmAttendee", handle_xml_aattendee_attribute);
		g_hash_table_insert(hooks->alarmtable, "AlarmSummary", handle_xml_asummary_attribute);

	}
	
	xml_parse_attribute(hooks, hooks->table, &root, vcal, target);
	
	*free_input = TRUE;
	*output = vformat_to_string(vcal, target);
	osync_trace(TRACE_SENSITIVE, "vevent output is: \n%s", *output);
	*outpsize = strlen(*output);
	osync_trace(TRACE_EXIT, "%s", __func__);
	
	return TRUE;
}

static osync_bool conv_xml_to_vevent10(void *user_data, char *input, int inpsize, char **output, int *outpsize, osync_bool *free_input, OSyncError **error)
{
	return conv_xml_to_vcal(user_data, input, inpsize, output, outpsize, free_input, error, VFORMAT_EVENT_10);
}

static osync_bool conv_xml_to_vevent20(void *user_data, char *input, int inpsize, char **output, int *outpsize, osync_bool *free_input, OSyncError **error)
{
	return conv_xml_to_vcal(user_data, input, inpsize, output, outpsize, free_input, error, VFORMAT_EVENT_20);
}

static osync_bool conv_xml_to_vtodo10(void *user_data, char *input, int inpsize, char **output, int *outpsize, osync_bool *free_input, OSyncError **error)
{
	return conv_xml_to_vcal(user_data, input, inpsize, output, outpsize, free_input, error, VFORMAT_TODO_10);
}

static osync_bool conv_xml_to_vtodo20(void *user_data, char *input, int inpsize, char **output, int *outpsize, osync_bool *free_input, OSyncError **error)
{
	return conv_xml_to_vcal(user_data, input, inpsize, output, outpsize, free_input, error, VFORMAT_TODO_20);
}

static void *init_xml_to_vcal(void)
{
	osync_trace(TRACE_ENTRY, "%s", __func__);
	
	OSyncHooksTable *hooks = g_malloc0(sizeof(OSyncHooksTable));
	
	hooks->table = g_hash_table_new(g_str_hash, g_str_equal);
	hooks->tztable = g_hash_table_new(g_str_hash, g_str_equal);
	hooks->comptable = g_hash_table_new(g_str_hash, g_str_equal);
	hooks->alarmtable = g_hash_table_new(g_str_hash, g_str_equal);
	
	//todo attributes
	insert_xml_attr_handler(hooks->comptable, "Uid", handle_xml_uid_attribute);
	insert_xml_attr_handler(hooks->comptable, "DateCalendarCreated", handle_xml_dtstamp_attribute);
	insert_xml_attr_handler(hooks->comptable, "Description", handle_xml_description_attribute);
	insert_xml_attr_handler(hooks->comptable, "Summary", handle_xml_summary_attribute);
	insert_xml_attr_handler(hooks->comptable, "PercentComplete", handle_xml_percent_complete_attribute);
	insert_xml_attr_handler(hooks->comptable, "Class", handle_xml_class_attribute);
	insert_xml_attr_handler(hooks->comptable, "Categories", handle_xml_categories_attribute);
	insert_xml_attr_handler(hooks->comptable, "Priority", handle_xml_priority_attribute);
	insert_xml_attr_handler(hooks->comptable, "Url", handle_xml_url_attribute);
	insert_xml_attr_handler(hooks->comptable, "Sequence", handle_xml_sequence_attribute);
	insert_xml_attr_handler(hooks->comptable, "LastModified", handle_xml_last_modified_attribute);
	insert_xml_attr_handler(hooks->comptable, "DateCreated", handle_xml_created_attribute);
	insert_xml_attr_handler(hooks->comptable, "RecurrenceDate", handle_xml_rdate_attribute);
	insert_xml_attr_handler(hooks->comptable, "Location", handle_xml_location_attribute);
	insert_xml_attr_handler(hooks->comptable, "Geo", handle_xml_geo_attribute);
	insert_xml_attr_handler(hooks->comptable, "Completed", handle_xml_completed_attribute);
	insert_xml_attr_handler(hooks->comptable, "Organizer", handle_xml_organizer_attribute);
	insert_xml_attr_handler(hooks->comptable, "RecurrenceID", handle_xml_recurid_attribute);
	insert_xml_attr_handler(hooks->comptable, "Status", handle_xml_status_attribute);
	insert_xml_attr_handler(hooks->comptable, "Duration", handle_xml_duration_attribute);
	insert_xml_attr_handler(hooks->comptable, "Attach", handle_xml_attach_attribute);
	insert_xml_attr_handler(hooks->comptable, "Attendee", handle_xml_attendee_attribute);
	insert_xml_attr_handler(hooks->comptable, "Contact", handle_xml_contact_attribute);
	insert_xml_attr_handler(hooks->comptable, "ExclusionRule", handle_xml_exrule_attribute);
	insert_xml_attr_handler(hooks->comptable, "RStatus", handle_xml_rstatus_attribute);
	insert_xml_attr_handler(hooks->comptable, "Related", handle_xml_related_attribute);
	insert_xml_attr_handler(hooks->comptable, "Resources", handle_xml_resources_attribute);


	/*FIXME: The functions below shouldn't be on comptable, but on other hash table */
	g_hash_table_insert(hooks->comptable, "Category", handle_xml_category_parameter);
	g_hash_table_insert(hooks->comptable, "Value", handle_xml_value_parameter);
	g_hash_table_insert(hooks->comptable, "AlternateRep", handle_xml_altrep_parameter);
	g_hash_table_insert(hooks->comptable, "CommonName", handle_xml_cn_parameter);
	g_hash_table_insert(hooks->comptable, "DelegatedFrom", handle_xml_delegated_from_parameter);
	g_hash_table_insert(hooks->comptable, "DelegatedTo", handle_xml_delegated_to_parameter);
	g_hash_table_insert(hooks->comptable, "Directory", handle_xml_dir_parameter);
	g_hash_table_insert(hooks->comptable, "FormaType", handle_xml_format_type_parameter);
	g_hash_table_insert(hooks->comptable, "FreeBusyType", handle_xml_fb_type_parameter);
	g_hash_table_insert(hooks->comptable, "Member", handle_xml_member_parameter);
	g_hash_table_insert(hooks->comptable, "PartStat", handle_xml_partstat_parameter);
	g_hash_table_insert(hooks->comptable, "Range", handle_xml_range_parameter);
	g_hash_table_insert(hooks->comptable, "Related", handle_xml_related_parameter);
	g_hash_table_insert(hooks->comptable, "RelationType", handle_xml_reltype_parameter);
	g_hash_table_insert(hooks->comptable, "Role", handle_xml_role_parameter);
	g_hash_table_insert(hooks->comptable, "RSVP", handle_xml_rsvp_parameter);
	g_hash_table_insert(hooks->comptable, "SentBy", handle_xml_sent_by_parameter);
	
	//vcal attributes
	g_hash_table_insert(hooks->table, "CalendarScale", handle_xml_calscale_attribute);
	g_hash_table_insert(hooks->table, "ProductID", handle_xml_prodid_attribute);
	g_hash_table_insert(hooks->table, "UnknownNode", xml_handle_unknown_attribute);
	g_hash_table_insert(hooks->table, "UnknownParameter", xml_handle_unknown_parameter);
	
	/*FIXME: The functions below shouldn't be on tztable, but on other hash table */
	g_hash_table_insert(hooks->tztable, "Category", handle_xml_category_parameter);
	g_hash_table_insert(hooks->tztable, "Rule", handle_xml_rule_parameter);
	g_hash_table_insert(hooks->tztable, "Value", handle_xml_value_parameter);
	g_hash_table_insert(hooks->tztable, "AlternateRep", handle_xml_altrep_parameter);
	g_hash_table_insert(hooks->tztable, "CommonName", handle_xml_cn_parameter);
	g_hash_table_insert(hooks->tztable, "DelegatedFrom", handle_xml_delegated_from_parameter);
	g_hash_table_insert(hooks->tztable, "DelegatedTo", handle_xml_delegated_to_parameter);
	g_hash_table_insert(hooks->tztable, "Directory", handle_xml_dir_parameter);
	g_hash_table_insert(hooks->tztable, "FormaType", handle_xml_format_type_parameter);
	g_hash_table_insert(hooks->tztable, "FreeBusyType", handle_xml_fb_type_parameter);
	g_hash_table_insert(hooks->tztable, "Member", handle_xml_member_parameter);
	g_hash_table_insert(hooks->tztable, "PartStat", handle_xml_partstat_parameter);
	g_hash_table_insert(hooks->tztable, "Range", handle_xml_range_parameter);
	g_hash_table_insert(hooks->tztable, "Related", handle_xml_related_parameter);
	g_hash_table_insert(hooks->tztable, "RelationType", handle_xml_reltype_parameter);
	g_hash_table_insert(hooks->tztable, "Role", handle_xml_role_parameter);
	g_hash_table_insert(hooks->tztable, "RSVP", handle_xml_rsvp_parameter);
	g_hash_table_insert(hooks->tztable, "SentBy", handle_xml_sent_by_parameter);
	

	/*FIXME: The functions below shouldn't be on alarmtable, but on other hash table */
	g_hash_table_insert(hooks->alarmtable, "Category", handle_xml_category_parameter);
	g_hash_table_insert(hooks->alarmtable, "Rule", handle_xml_rule_parameter);
	g_hash_table_insert(hooks->alarmtable, "Value", handle_xml_value_parameter);
	g_hash_table_insert(hooks->alarmtable, "AlternateRep", handle_xml_altrep_parameter);
	g_hash_table_insert(hooks->alarmtable, "CommonName", handle_xml_cn_parameter);
	g_hash_table_insert(hooks->alarmtable, "DelegatedFrom", handle_xml_delegated_from_parameter);
	g_hash_table_insert(hooks->alarmtable, "DelegatedTo", handle_xml_delegated_to_parameter);
	g_hash_table_insert(hooks->alarmtable, "Directory", handle_xml_dir_parameter);
	g_hash_table_insert(hooks->alarmtable, "FormaType", handle_xml_format_type_parameter);
	g_hash_table_insert(hooks->alarmtable, "FreeBusyType", handle_xml_fb_type_parameter);
	g_hash_table_insert(hooks->alarmtable, "Member", handle_xml_member_parameter);
	g_hash_table_insert(hooks->alarmtable, "PartStat", handle_xml_partstat_parameter);
	g_hash_table_insert(hooks->alarmtable, "Range", handle_xml_range_parameter);
	g_hash_table_insert(hooks->alarmtable, "Related", handle_xml_related_parameter);
	g_hash_table_insert(hooks->alarmtable, "RelationType", handle_xml_reltype_parameter);
	g_hash_table_insert(hooks->alarmtable, "Role", handle_xml_role_parameter);
	g_hash_table_insert(hooks->alarmtable, "RSVP", handle_xml_rsvp_parameter);
	g_hash_table_insert(hooks->alarmtable, "SentBy", handle_xml_sent_by_parameter);
	
	osync_trace(TRACE_EXIT, "%s: %p", __func__, hooks);
	return (void *)hooks;
}

static void fin_xml_to_vcal(void *data)
{
	OSyncHooksTable *hooks = (OSyncHooksTable *)data;
	g_hash_table_destroy(hooks->table);
	g_free(hooks);
}

static time_t get_revision(OSyncChange *change, const char *path, OSyncError **error)
{
	osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, change, error);
	
	xmlDoc *doc = (xmlDoc *)osync_change_get_data(change);
	
	xmlXPathObject *xobj = osxml_get_nodeset(doc, path);
		
	xmlNodeSet *nodes = xobj->nodesetval;
		
	int size = (nodes) ? nodes->nodeNr : 0;
	if (size != 1) {
		osync_error_set(error, OSYNC_ERROR_GENERIC, "Unable to find the revision");
		osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
		return -1;
	}
	
	char *revision = (char*)xmlNodeGetContent(nodes->nodeTab[0]);
	
	time_t time = vformat_time_to_unix(revision);
	g_free(revision);
	xmlXPathFreeObject(xobj);
	osync_trace(TRACE_EXIT, "%s: %i", __func__, time);
	return time;
}

static time_t get_todo_revision(OSyncChange *change, OSyncError **error)
{
	return get_revision(change, "/vcal/Todo/LastModified", error);
}

static time_t get_event_revision(OSyncChange *change, OSyncError **error)
{
	return get_revision(change, "/vcal/Event/LastModified", error);
}

void get_info(OSyncEnv *env)
{
	//Calendar
	osync_env_register_objtype(env, "event");
	osync_env_register_objformat(env, "event", "xml-event");
	osync_env_format_set_compare_func(env, "xml-event", compare_vevent);
	osync_env_format_set_destroy_func(env, "xml-event", destroy_xml);
	osync_env_format_set_print_func(env, "xml-event", print_vcal);
	osync_env_format_set_copy_func(env, "xml-event", osxml_copy);
	osync_env_format_set_revision_func(env, "xml-event", get_event_revision);
	osync_env_format_set_marshall_func(env, "xml-event", osxml_marshall);
	osync_env_format_set_demarshall_func(env, "xml-event", osxml_demarshall);
	
	osync_env_register_converter(env, CONVERTER_CONV, "vevent10", "xml-event", conv_vcal_to_xml);
	osync_env_converter_set_init(env, "vevent10", "xml-event", init_vcal_to_xml, fin_vcal_to_xml);
	osync_env_register_converter(env, CONVERTER_CONV, "xml-event", "vevent10", conv_xml_to_vevent10);
	osync_env_converter_set_init(env, "xml-event", "vevent10", init_xml_to_vcal, fin_xml_to_vcal);
	
	osync_env_register_converter(env, CONVERTER_CONV, "vevent20", "xml-event", conv_vcal_to_xml);
	osync_env_converter_set_init(env, "vevent20", "xml-event", init_ical_to_xml, fin_vcal_to_xml);
	osync_env_register_converter(env, CONVERTER_CONV, "xml-event", "vevent20", conv_xml_to_vevent20);
	osync_env_converter_set_init(env, "xml-event", "vevent20", init_xml_to_vcal, fin_xml_to_vcal);
	
	//Todo
	osync_env_register_objtype(env, "todo");
	osync_env_register_objformat(env, "todo", "xml-todo");
	osync_env_format_set_compare_func(env, "xml-todo", compare_vtodo);
	osync_env_format_set_destroy_func(env, "xml-todo", destroy_xml);
	osync_env_format_set_print_func(env, "xml-todo", print_vcal);
	osync_env_format_set_copy_func(env, "xml-todo", osxml_copy);
	osync_env_format_set_revision_func(env, "xml-todo", get_todo_revision);
	osync_env_format_set_marshall_func(env, "xml-todo", osxml_marshall);
	osync_env_format_set_demarshall_func(env, "xml-todo", osxml_demarshall);
	
	osync_env_register_converter(env, CONVERTER_CONV, "vtodo10", "xml-todo", conv_vcal_to_xml);
	osync_env_converter_set_init(env, "vtodo10", "xml-todo", init_vcal_to_xml, fin_vcal_to_xml);
	osync_env_register_converter(env, CONVERTER_CONV, "xml-todo", "vtodo10", conv_xml_to_vtodo10);
	osync_env_converter_set_init(env, "xml-todo", "vtodo10", init_xml_to_vcal, fin_xml_to_vcal);
	
	osync_env_register_converter(env, CONVERTER_CONV, "vtodo20", "xml-todo", conv_vcal_to_xml);
	osync_env_converter_set_init(env, "vtodo20", "xml-todo", init_ical_to_xml, fin_vcal_to_xml);
	osync_env_register_converter(env, CONVERTER_CONV, "xml-todo", "vtodo20", conv_xml_to_vtodo20);
	osync_env_converter_set_init(env, "xml-todo", "vtodo20", init_xml_to_vcal, fin_xml_to_vcal);
}