/*
* 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);
}
syntax highlighted by Code2HTML, v. 0.9.1