/*
* icalendar server for gnomecal
*
* This module interfaces between libical and the gnomecal internal
* representation
*
* Copyright (C) 1999 The Free Software Foundation
* Authors:
* Russell Steinthal (rms39@columbia.edu)
*
*/
#include <config.h>
#include <unistd.h>
#include <sys/stat.h>
#include "icalendar.h"
static time_t icaltime_to_timet (struct icaltimetype* i);
static CalendarAlarm* parse_alarm (icalproperty *prop);
static iCalPerson* parse_person (icalproperty *prop, gchar *value);
static iCalRelation* parse_related (icalproperty *prop);
/* Duplicate a string without memory leaks */
static gchar* copy_str (gchar** store, gchar* src)
{
if (*store)
g_free (*store);
return (*store = g_strdup (src));
}
static GList*
copy_to_list (GList** store, gchar* src)
{
*store = g_list_prepend (*store, g_strdup (src));
return *store;
}
iCalObject *
ical_object_create_from_icalcomponent (icalcomponent* comp)
{
iCalObject *ical = NULL;
iCalPerson *person;
icalcomponent *subcomp;
icalproperty *prop;
icalparameter *param;
struct icaltimetype ictime;
time_t *pt;
CalendarAlarm *alarm = NULL;
icalcomponent_kind compType;
struct icalgeotype geo;
struct icalperiodtype period;
gboolean root = FALSE;
gboolean attachment = FALSE;
char *tmpStr; /* this is a library-owned string */
ical = g_new0 (iCalObject, 1);
compType = icalcomponent_isa (comp);
switch (compType) {
case ICAL_XROOT_COMPONENT:
root = TRUE;
break;
case ICAL_XATTACH_COMPONENT:
attachment = TRUE;
break;
case ICAL_VEVENT_COMPONENT:
ical->type = ICAL_EVENT;
break;
case ICAL_VTODO_COMPONENT:
ical->type = ICAL_TODO;
break;
case ICAL_VJOURNAL_COMPONENT:
ical->type = ICAL_JOURNAL;
break;
case ICAL_VCALENDAR_COMPONENT:
/* FIXME: what does this mean? */
break;
case ICAL_VFREEBUSY_COMPONENT:
ical->type = ICAL_FBREQUEST;
/* NOTE: This is not conclusive- you need to analyze
properties to determine whether this is an
FBREQUEST or an FBREPLY */
break;
case ICAL_VTIMEZONE_COMPONENT:
ical->type = ICAL_TIMEZONE;
break;
case ICAL_VALARM_COMPONENT:
case ICAL_XAUDIOALARM_COMPONENT:
case ICAL_XDISPLAYALARM_COMPONENT:
case ICAL_XEMAILALARM_COMPONENT:
case ICAL_XPROCEDUREALARM_COMPONENT:
/* this should not be reached, since this loop should
only be processing first level components */
break;
case ICAL_XSTANDARD_COMPONENT:
/* FIXME: what does this mean? */
break;
case ICAL_XDAYLIGHT_COMPONENT:
/* FIXME: what does this mean? */
break;
case ICAL_X_COMPONENT:
/* FIXME: what does this mean? */
break;
case ICAL_VSCHEDULE_COMPONENT:
/* FIXME: what does this mean? */
break;
case ICAL_XLICINVALID_COMPONENT:
/* FIXME: what does this mean? */
break;
case ICAL_NO_COMPONENT:
case ICAL_ANY_COMPONENT:
/* should not occur */
break;
case ICAL_VQUERY_COMPONENT:
case ICAL_VCAR_COMPONENT:
case ICAL_VCOMMAND_COMPONENT:
/* FIXME: what does this mean? */
break;
}
prop = icalcomponent_get_first_property (comp, ICAL_ANY_PROPERTY);
while (prop) {
switch (icalproperty_isa (prop)) {
case ICAL_CALSCALE_PROPERTY:
if (g_strcasecmp (icalproperty_get_calscale (prop),
"GREGORIAN"))
g_warning ("Unknown calendar format.");
break;
case ICAL_METHOD_PROPERTY:
/* FIXME: implement something here */
break;
case ICAL_ATTACH_PROPERTY:
/* FIXME: not yet implemented */
break;
case ICAL_CATEGORIES_PROPERTY:
copy_to_list (&ical->categories,
icalproperty_get_categories (prop));
break;
case ICAL_CLASS_PROPERTY:
copy_str (&ical->class, icalproperty_get_class (prop));
break;
case ICAL_COMMENT_PROPERTY:
tmpStr = icalproperty_get_comment (prop);
tmpStr = g_strconcat (icalproperty_get_comment (prop),
ical->comment,
NULL);
if (ical->comment)
g_free (ical->comment);
ical->comment = tmpStr;
break;
case ICAL_DESCRIPTION_PROPERTY:
copy_str (&ical->desc,
icalproperty_get_description (prop));
break;
case ICAL_GEO_PROPERTY:
geo = icalproperty_get_geo (prop);
ical->geo.latitude = geo.lat;
ical->geo.longitude = geo.lon;
ical->geo.valid = TRUE;
break;
case ICAL_LOCATION_PROPERTY:
copy_str (&ical->location,
icalproperty_get_location (prop));
break;
case ICAL_PERCENTCOMPLETE_PROPERTY:
ical->percent = icalproperty_get_percentcomplete (prop);
break;
case ICAL_PRIORITY_PROPERTY:
ical->priority = icalproperty_get_priority (prop);
if (ical->priority < 0 || ical->priority > 9)
g_warning ("Priority out-of-range (see RFC2445)");
break;
case ICAL_RESOURCES_PROPERTY:
copy_to_list (&ical->resources,
icalproperty_get_resources (prop));
break;
case ICAL_STATUS_PROPERTY:
copy_str (&ical->status,
icalproperty_get_status (prop));
break;
case ICAL_SUMMARY_PROPERTY:
copy_str (&ical->summary,
icalproperty_get_summary (prop));
break;
case ICAL_COMPLETED_PROPERTY:
ictime = icalproperty_get_completed (prop);
ical->completed = icaltime_to_timet (&ictime);
break;
case ICAL_DTEND_PROPERTY:
ictime = icalproperty_get_dtend (prop);
ical->dtend = icaltime_to_timet (&ictime);
param = icalproperty_get_first_parameter (prop,
ICAL_VALUE_PARAMETER);
ical->date_only = (icalparameter_get_value (param) ==
ICAL_VALUE_DATE);
/* FIXME: We should handle timezone specifiers */
break;
case ICAL_DUE_PROPERTY:
ictime = icalproperty_get_due (prop);
ical->dtend = icaltime_to_timet (&ictime);
param = icalproperty_get_first_parameter (prop,
ICAL_VALUE_PARAMETER);
ical->date_only = (icalparameter_get_value (param) ==
ICAL_VALUE_DATE);
/* FIXME: We should handle timezone specifiers */
break;
case ICAL_DTSTART_PROPERTY:
ictime = icalproperty_get_dtstart (prop);
ical->dtstart = icaltime_to_timet (&ictime);
param = icalproperty_get_first_parameter (prop,
ICAL_VALUE_PARAMETER);
ical->date_only = (icalparameter_get_value (param) ==
ICAL_VALUE_DATE);
/* FIXME: We should handle timezone specifiers */
break;
case ICAL_DURATION_PROPERTY:
/* FIXME: I don't see the necessary libical function */
break;
case ICAL_FREEBUSY_PROPERTY:
period = icalproperty_get_freebusy (prop);
ical->dtstart = icaltime_to_timet (&(period.start));
/* FIXME: period.end is specified as being relative to start, so
this may not be correct */
ical->dtend = icaltime_to_timet (&(period.end));
break;
case ICAL_TRANSP_PROPERTY:
tmpStr = icalproperty_get_transp (prop);
/* do not i18n the following string constant! */
if (!g_strcasecmp (tmpStr, "TRANSPARENT"))
ical->transp = ICAL_TRANSPARENT;
else
ical->transp = ICAL_OPAQUE;
break;
case ICAL_TZID_PROPERTY:
case ICAL_TZNAME_PROPERTY:
case ICAL_TZOFFSETFROM_PROPERTY:
case ICAL_TZOFFSETTO_PROPERTY:
case ICAL_TZURL_PROPERTY:
/* no implementation for now */
break;
case ICAL_ATTENDEE_PROPERTY:
tmpStr = icalproperty_get_attendee (prop);
person = parse_person (prop, tmpStr);
ical->attendee = g_list_prepend (ical->attendee,
person);
break;
case ICAL_CONTACT_PROPERTY:
tmpStr = icalproperty_get_contact (prop);
person = parse_person (prop, tmpStr);
ical->contact = g_list_prepend (ical->contact, person);
break;
case ICAL_ORGANIZER_PROPERTY:
tmpStr = icalproperty_get_organizer (prop);
person = parse_person (prop, tmpStr);
if (ical->organizer)
g_free (ical->organizer);
ical->organizer = person;
break;
case ICAL_RECURRENCEID_PROPERTY:
ictime = icalproperty_get_recurrenceid (prop);
ical->recurid = icaltime_to_timet (&ictime);
/* FIXME: Range parameter not implemented */
break;
case ICAL_RELATEDTO_PROPERTY:
ical->related = g_list_prepend (ical->related,
parse_related (prop));
break;
case ICAL_URL_PROPERTY:
copy_str (&ical->url,
icalproperty_get_url (prop));
break;
case ICAL_UID_PROPERTY:
copy_str (&ical->uid,
icalproperty_get_uid (prop));
break;
case ICAL_EXDATE_PROPERTY:
/* FIXME: This does not appear to parse
multiple exdate values in one property, as
allowed by the RFC; needs a libical fix */
ictime = icalproperty_get_exdate (prop);
pt = g_new0 (time_t, 1);
*pt = icaltime_to_timet (&ictime);
ical->exdate = g_list_prepend (ical->exdate, pt);
break;
case ICAL_EXRULE_PROPERTY:
case ICAL_RDATE_PROPERTY:
case ICAL_RRULE_PROPERTY:
/* FIXME: need recursion processing */
break;
case ICAL_ACTION_PROPERTY:
case ICAL_REPEAT_PROPERTY:
case ICAL_TRIGGER_PROPERTY:
/* should only occur in VALARM's, handled below */
g_assert_not_reached();
break;
case ICAL_CREATED_PROPERTY:
ictime = icalproperty_get_created (prop);
ical->created = icaltime_to_timet (&ictime);
break;
case ICAL_DTSTAMP_PROPERTY:
ictime = icalproperty_get_dtstamp (prop);
ical->dtstamp = icaltime_to_timet (&ictime);
break;
case ICAL_LASTMODIFIED_PROPERTY:
ictime = icalproperty_get_lastmodified (prop);
ical->last_mod = icaltime_to_timet (&ictime);
break;
case ICAL_SEQUENCE_PROPERTY:
ical->seq = icalproperty_get_sequence (prop);
break;
case ICAL_REQUESTSTATUS_PROPERTY:
copy_str (&ical->rstatus,
icalproperty_get_requeststatus (prop));
break;
case ICAL_X_PROPERTY:
g_warning ("Unsupported X-property: %s",
icalproperty_as_ical_string (prop));
break;
case ICAL_XLICERROR_PROPERTY:
g_warning ("Unsupported property: %s",
icalproperty_get_xlicerror (prop));
break;
case ICAL_PRODID_PROPERTY:
case ICAL_VERSION_PROPERTY:
/* nothing to do for this property */
break;
default:
g_warning ("Unsupported property: %s", icalproperty_as_ical_string
(prop));
break;
}
prop = icalcomponent_get_next_property (comp,
ICAL_ANY_PROPERTY);
}
/* now parse subcomponents --- should only be VALARM's */
subcomp = icalcomponent_get_first_component (comp,
ICAL_ANY_COMPONENT);
while (subcomp) {
compType = icalcomponent_isa (subcomp);
switch (compType) {
case ICAL_VALARM_COMPONENT:
alarm = parse_alarm (subcomp);
if (alarm)
ical->alarms = g_list_prepend (ical->alarms,
alarm);
break;
default:
g_warning ("Only nested VALARM components are supported.");
}
subcomp = icalcomponent_get_next_component (comp,
ICAL_ANY_COMPONENT);
}
return ical;
}
static time_t icaltime_to_timet (struct icaltimetype* i)
{
extern long timezone;
struct tm t;
time_t ret;
t.tm_year = i->year - 1900;
t.tm_mon = i->month - 1;
t.tm_mday = i->day;
if (!i->is_date) {
t.tm_hour = i->hour;
t.tm_min = i->minute;
t.tm_sec = i->second;
} else {
t.tm_hour = 0;
t.tm_min = 0;
t.tm_sec = 0;
}
ret = mktime(&t);
return ret - (i->is_utc ? timezone : 0);
}
static iCalPerson*
parse_person (icalproperty* prop, gchar* value)
{
icalparameter* param;
icalparameter_role role;
icalparameter_partstat partstat;
icalparameter_cutype cutype;
iCalPerson* ret;
ret = g_new0 (iCalPerson, 1);
ret->addr = g_strdup (value);
param = icalproperty_get_first_parameter (prop,
ICAL_CN_PARAMETER);
ret->name = g_strdup (icalparameter_get_cn (param));
param = icalproperty_get_first_parameter (prop,
ICAL_ROLE_PARAMETER);
if (param) {
role = icalparameter_get_role (param);
switch (role) {
case ICAL_ROLE_CHAIR:
ret->role = g_strdup ("CHAIR");
break;
case ICAL_ROLE_REQPARTICIPANT:
ret->role = g_strdup ("REQPARTICIPANT");
break;
case ICAL_ROLE_OPTPARTICIPANT:
ret->role = g_strdup ("OPTPARTICIPANT");
break;
case ICAL_ROLE_NONPARTICIPANT:
ret->role = g_strdup ("NONPARTICIPANT");
break;
case ICAL_ROLE_XNAME:
default:
ret->role = g_strdup ("UNKNOWN");
break;
}
} else
ret->role = g_strdup ("REQPARTICIPANT");
param = icalproperty_get_first_parameter (prop, ICAL_PARTSTAT_PARAMETER);
if (param) {
partstat = icalparameter_get_partstat (param);
switch (partstat) {
case ICAL_PARTSTAT_NEEDSACTION:
ret->partstat = g_strdup ("NEEDSACTION");
break;
case ICAL_PARTSTAT_ACCEPTED:
ret->partstat = g_strdup ("ACCEPTED");
break;
case ICAL_PARTSTAT_DECLINED:
ret->partstat = g_strdup ("DECLINED");
break;
case ICAL_PARTSTAT_TENTATIVE:
ret->partstat = g_strdup ("TENTATIVE");
break;
case ICAL_PARTSTAT_DELEGATED:
ret->partstat = g_strdup ("DELEGATED");
break;
case ICAL_PARTSTAT_COMPLETED:
ret->partstat = g_strdup ("COMPLETED");
break;
case ICAL_PARTSTAT_INPROCESS:
ret->partstat = g_strdup ("INPROCESS");
break;
case ICAL_PARTSTAT_XNAME:
ret->partstat = g_strdup (icalparameter_get_xvalue (param));
break;
default:
ret->partstat = g_strdup ("UNKNOWN");
break;
}
} else
ret->partstat = g_strdup ("NEEDSACTION");
param = icalproperty_get_first_parameter (prop, ICAL_RSVP_PARAMETER);
if (param)
ret->rsvp = icalparameter_get_rsvp (param);
else
ret->rsvp = FALSE;
param = icalproperty_get_first_parameter (prop, ICAL_CUTYPE_PARAMETER
);
if (param) {
cutype = icalparameter_get_cutype (param);
switch (cutype) {
case ICAL_CUTYPE_INDIVIDUAL:
ret->cutype = g_strdup ("INDIVIDUAL");
break;
case ICAL_CUTYPE_GROUP:
ret->cutype = g_strdup ("GROUP");
break;
case ICAL_CUTYPE_RESOURCE:
ret->cutype = g_strdup ("RESOURCE");
break;
case ICAL_CUTYPE_ROOM:
ret->cutype = g_strdup ("ROOM");
break;
case ICAL_CUTYPE_UNKNOWN:
case ICAL_CUTYPE_XNAME:
default:
ret->cutype = g_strdup ("UNKNOWN");
break;
}
} else
ret->cutype = g_strdup ("INDIVIDUAL");
param = icalproperty_get_first_parameter (prop, ICAL_MEMBER_PARAMETER
);
while (param) {
copy_to_list (&ret->member, icalparameter_get_member (param));
param = icalproperty_get_next_parameter (prop,
ICAL_MEMBER_PARAMETER);
}
param = icalproperty_get_first_parameter (prop, ICAL_DELEGATEDTO_PARAMETER);
while (param) {
copy_to_list (&ret->deleg_to,
icalparameter_get_delegatedto (param));
param = icalproperty_get_next_parameter (prop,
ICAL_DELEGATEDTO_PARAMETER);
}
param = icalproperty_get_first_parameter (prop, ICAL_DELEGATEDFROM_PARAMETER);
while (param) {
copy_to_list (&ret->deleg_from,
icalparameter_get_delegatedfrom (param));
param = icalproperty_get_next_parameter (prop,
ICAL_DELEGATEDFROM_PARAMETER);
}
param = icalproperty_get_first_parameter (prop, ICAL_SENTBY_PARAMETER
);
copy_str (&ret->sent_by,
icalparameter_get_sentby (param));
param = icalproperty_get_first_parameter (prop, ICAL_DIR_PARAMETER);
while (param) {
copy_to_list (&ret->deleg_to,
icalparameter_get_delegatedto (param));
param = icalproperty_get_next_parameter (prop,
ICAL_DIR_PARAMETER);
}
return ret;
}
static iCalRelation*
parse_related (icalproperty* prop)
{
iCalRelation* rel;
icalparameter* param;
icalparameter_reltype type;
rel = g_new0 (iCalRelation, 1);
rel->uid = g_strdup (icalproperty_get_relatedto (prop));
param = icalproperty_get_first_parameter (prop,
ICAL_RELTYPE_PARAMETER);
if (param) {
type = icalparameter_get_reltype (param);
switch (type) {
case ICAL_RELTYPE_PARENT:
rel->reltype = g_strdup ("PARENT");
break;
case ICAL_RELTYPE_CHILD:
rel->reltype = g_strdup ("CHILD");
break;
case ICAL_RELTYPE_SIBLING:
rel->reltype = g_strdup ("SIBLING");
break;
case ICAL_RELTYPE_XNAME:
rel->reltype = g_strdup (icalparameter_get_xvalue (param));
break;
default:
rel->reltype = g_strdup ("UNKNOWN");
break;
}
} else
rel->reltype = g_strdup ("PARENT");
return rel;
}
#ifdef TEST
int main(int argc, char* argv[])
{
icalcomponent* comp;
comp = icalendar_parse_file (argv[1]);
printf ("%s\n", icalcomponent_as_ical_string (comp));
return 0;
}
#endif
static CalendarAlarm*
parse_alarm (icalcomponent* comp)
{
CalendarAlarm *alarm;
icalproperty *prop;
char *tmpStr;
struct icaldurationtype dur;
struct icalattachtype attach;
g_return_val_if_fail (comp != NULL, NULL);
alarm = g_new0 (CalendarAlarm, 1);
prop = icalcomponent_get_first_property (comp, ICAL_ANY_PROPERTY);
while (prop) {
switch (icalproperty_isa (prop)) {
case ICAL_ACTION_PROPERTY:
tmpStr = icalproperty_get_action (prop);
if (!g_strcasecmp (tmpStr, "AUDIO"))
alarm->type = ALARM_AUDIO;
else if (!g_strcasecmp (tmpStr, "DISPLAY"))
alarm->type = ALARM_DISPLAY;
else if (!g_strcasecmp (tmpStr, "EMAIL"))
alarm->type = ALARM_MAIL;
else if (!g_strcasecmp (tmpStr, "PROCEDURE"))
alarm->type = ALARM_PROGRAM;
else
g_warning ("Unsupported alarm type!");
break;
case ICAL_TRIGGER_PROPERTY:
/* FIXME: waiting on proper libical support */
break;
case ICAL_REPEAT_PROPERTY:
alarm->snooze_repeat = icalproperty_get_repeat (prop);
break;
case ICAL_DURATION_PROPERTY:
dur = icalproperty_get_duration (prop);
alarm->snooze_secs = icaldurationtype_as_timet (dur);
break;
case ICAL_ATTACH_PROPERTY:
attach = icalproperty_get_attach (prop);
copy_str (&alarm->attach,
icalattachtype_get_url (&attach));
break;
case ICAL_DESCRIPTION_PROPERTY:
copy_str (&alarm->desc,
icalproperty_get_description (prop));
break;
case ICAL_SUMMARY_PROPERTY:
copy_str (&alarm->summary,
icalproperty_get_summary (prop));
break;
case ICAL_ATTENDEE_PROPERTY:
copy_str (&alarm->attendee,
icalproperty_get_attendee (prop));
break;
default:
g_warning ("Unsupported alarm property: %s",
icalproperty_as_ical_string (prop));
break;
}
prop = icalcomponent_get_next_property (comp,
ICAL_ANY_PROPERTY);
}
return alarm;
}
