/**
* get ICalendar VTIMEZONE block from ECalComponentWithTZ
*
* @param ectz
* An evolution event/task/note type which may contain a time zone.
*
* @return the ICalendar VTIMEZONE block
*/
static gchar*
get_vtimezone (const ECalComponentWithTZ *ectz)
{
icalcomponent *icc = NULL;
icalcomponent *cloned_icc = NULL;
icalproperty *dtstamp = NULL;
icalproperty *uid = NULL;
gchar *ical_str = NULL;
if (ectz == NULL || ectz->maincomp == NULL || ectz->timezone == NULL)
return NULL;
icc = e_cal_component_get_icalcomponent (ectz->timezone);
cloned_icc = icalcomponent_new_clone (icc);
/* uid and dtstamp are not needed (nor wanted) in timezone block */
uid = icalcomponent_get_first_property(cloned_icc, ICAL_UID_PROPERTY);
icalcomponent_remove_property (cloned_icc, uid);
free(uid);
dtstamp = icalcomponent_get_first_property(cloned_icc, ICAL_DTSTAMP_PROPERTY);
icalcomponent_remove_property (cloned_icc, dtstamp);
free(dtstamp);
/* memory returned by *_as_ical_string() is owned by libical */
ical_str = g_strdup (icalcomponent_as_ical_string (cloned_icc));
icalcomponent_free (cloned_icc);
return ical_str;
}
void
scalix_appointment_unset (ScalixAppointment * comp, const char *key)
{
icalcomponent *icomp;
icalproperty *icalprop;
const char *x_val;
GSList *list, *iter;
list = NULL;
icomp = e_cal_component_get_icalcomponent (E_CAL_COMPONENT (comp));
icalprop = icalcomponent_get_first_property (icomp, ICAL_X_PROPERTY);
while (icalprop) {
const char *x_name;
x_name = icalproperty_get_x_name (icalprop);
x_val = icalproperty_get_x (icalprop);
if (!strcmp (x_name, key)) {
list = g_slist_prepend (list, icalprop);
}
icalprop = icalcomponent_get_next_property (icomp, ICAL_X_PROPERTY);
}
for (iter = list; iter; iter = iter->next) {
icalprop = iter->data;
icalcomponent_remove_property (icomp, icalprop);
icalproperty_free (icalprop);
}
return;
}
/** Set icalcomponent X-* property.
*
* @param comp iCal component.
* @param key Property name (i.e. X-EEE-WHATEVER).
* @param value Property value.
*/
static void icomp_x_prop_set(icalcomponent *comp, const char *key, const char *value)
{
icalproperty *iter;
g_return_if_fail(comp != NULL);
g_return_if_fail(key != NULL);
again:
for (iter = icalcomponent_get_first_property(comp, ICAL_X_PROPERTY);
iter;
iter = icalcomponent_get_next_property(comp, ICAL_X_PROPERTY))
{
const char *str = icalproperty_get_x_name(iter);
if (str && !g_strcmp0(str, key))
{
icalcomponent_remove_property(comp, iter);
icalproperty_free(iter);
goto again;
}
}
if (value)
{
iter = icalproperty_new_x(value);
icalproperty_set_x_name(iter, key);
icalcomponent_add_property(comp, iter);
}
}
void calIcalComponent::ClearAllProperties(icalproperty_kind kind)
{
for (icalproperty *prop = icalcomponent_get_first_property(mComponent, kind), *next;
prop; prop = next)
{
next = icalcomponent_get_next_property(mComponent, kind);
icalcomponent_remove_property(mComponent, prop);
icalproperty_free(prop);
}
}
void Todo::removeProperty(icalproperty_kind kind) {
while (true) {
icalproperty * ptrOldProperty = icalcomponent_get_first_property(_ptrIcal, kind);
if (ptrOldProperty == nullptr)
break;
else
icalcomponent_remove_property(_ptrIcal, ptrOldProperty);
}
}
void icalcomponent_remove_invitee(icalcomponent *comp, icalproperty *prop)
{
if (icalcomponent_isa(comp) == ICAL_VPOLL_COMPONENT) {
icalcomponent *vvoter = icalproperty_get_parent(prop);
icalcomponent_remove_component(comp, vvoter);
icalcomponent_free(vvoter);
}
else {
icalcomponent_remove_property(comp, prop);
icalproperty_free(prop);
}
}
static void
set_transparency (ECalModelComponent *comp_data,
gconstpointer value)
{
icalproperty *prop;
prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_TRANSP_PROPERTY);
if (string_is_empty (value)) {
if (prop) {
icalcomponent_remove_property (comp_data->icalcomp, prop);
icalproperty_free (prop);
}
} else {
icalproperty_transp transp;
if (!g_ascii_strcasecmp (value, "FREE"))
transp = ICAL_TRANSP_TRANSPARENT;
else if (!g_ascii_strcasecmp (value, "OPAQUE"))
transp = ICAL_TRANSP_OPAQUE;
else {
if (prop) {
icalcomponent_remove_property (comp_data->icalcomp, prop);
icalproperty_free (prop);
}
return;
}
if (prop)
icalproperty_set_transp (prop, transp);
else {
prop = icalproperty_new_transp (transp);
icalcomponent_add_property (comp_data->icalcomp, prop);
}
}
}
/* Fills the procedure alarm data with the values from the widgets */
static void
palarm_widgets_to_alarm (Dialog *dialog,
ECalComponentAlarm *alarm)
{
gchar *program;
icalattach *attach;
gchar *str;
ECalComponentText description;
icalcomponent *icalcomp;
icalproperty *icalprop;
program = e_dialog_editable_get (dialog->palarm_program);
attach = icalattach_new_from_url (program ? program : "");
g_free (program);
e_cal_component_alarm_set_attach (alarm, attach);
icalattach_unref (attach);
str = e_dialog_editable_get (dialog->palarm_args);
description.value = str;
description.altrep = NULL;
e_cal_component_alarm_set_description (alarm, &description);
g_free (str);
/* remove the X-EVOLUTION-NEEDS-DESCRIPTION property, so that
* we don't re-set the alarm's description */
icalcomp = e_cal_component_alarm_get_icalcomponent (alarm);
icalprop = icalcomponent_get_first_property (icalcomp, ICAL_X_PROPERTY);
while (icalprop) {
const gchar *x_name;
x_name = icalproperty_get_x_name (icalprop);
if (!strcmp (x_name, "X-EVOLUTION-NEEDS-DESCRIPTION")) {
icalcomponent_remove_property (icalcomp, icalprop);
break;
}
icalprop = icalcomponent_get_next_property (icalcomp, ICAL_X_PROPERTY);
}
}
/* Fills the display alarm data with the values from the widgets */
static void
dalarm_widgets_to_alarm (Dialog *dialog,
ECalComponentAlarm *alarm)
{
gchar *str;
ECalComponentText description;
GtkTextBuffer *text_buffer;
GtkTextIter text_iter_start, text_iter_end;
icalcomponent *icalcomp;
icalproperty *icalprop;
if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dialog->dalarm_message)))
return;
text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (dialog->dalarm_description));
gtk_text_buffer_get_start_iter (text_buffer, &text_iter_start);
gtk_text_buffer_get_end_iter (text_buffer, &text_iter_end);
str = gtk_text_buffer_get_text (text_buffer, &text_iter_start, &text_iter_end, FALSE);
description.value = str;
description.altrep = NULL;
e_cal_component_alarm_set_description (alarm, &description);
g_free (str);
/* remove the X-EVOLUTION-NEEDS-DESCRIPTION property, so that
* we don't re-set the alarm's description */
icalcomp = e_cal_component_alarm_get_icalcomponent (alarm);
icalprop = icalcomponent_get_first_property (icalcomp, ICAL_X_PROPERTY);
while (icalprop) {
const gchar *x_name;
x_name = icalproperty_get_x_name (icalprop);
if (!strcmp (x_name, "X-EVOLUTION-NEEDS-DESCRIPTION")) {
icalcomponent_remove_property (icalcomp, icalprop);
break;
}
icalprop = icalcomponent_get_next_property (icalcomp, ICAL_X_PROPERTY);
}
}
static void
set_location (ECalModelComponent *comp_data,
gconstpointer value)
{
icalproperty *prop;
prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_LOCATION_PROPERTY);
if (string_is_empty (value)) {
if (prop) {
icalcomponent_remove_property (comp_data->icalcomp, prop);
icalproperty_free (prop);
}
} else {
if (prop)
icalproperty_set_location (prop, (const gchar *) value);
else {
prop = icalproperty_new_location ((const gchar *) value);
icalcomponent_add_property (comp_data->icalcomp, prop);
}
}
}
/* Fills the mail alarm data with the values from the widgets */
static void
malarm_widgets_to_alarm (Dialog *dialog,
ECalComponentAlarm *alarm)
{
gchar *str;
ECalComponentText description;
GSList *attendee_list = NULL;
GtkTextBuffer *text_buffer;
GtkTextIter text_iter_start, text_iter_end;
ENameSelectorModel *name_selector_model;
EDestinationStore *destination_store;
GList *destinations;
icalcomponent *icalcomp;
icalproperty *icalprop;
GList *l;
/* Attendees */
name_selector_model = e_name_selector_peek_model (dialog->name_selector);
e_name_selector_model_peek_section (name_selector_model, section_name, NULL, &destination_store);
destinations = e_destination_store_list_destinations (destination_store);
for (l = destinations; l; l = g_list_next (l)) {
EDestination *dest;
ECalComponentAttendee *a;
dest = l->data;
a = g_new0 (ECalComponentAttendee, 1);
a->value = e_destination_get_email (dest);
a->cn = e_destination_get_name (dest);
a->cutype = ICAL_CUTYPE_INDIVIDUAL;
a->status = ICAL_PARTSTAT_NEEDSACTION;
a->role = ICAL_ROLE_REQPARTICIPANT;
attendee_list = g_slist_append (attendee_list, a);
}
e_cal_component_alarm_set_attendee_list (alarm, attendee_list);
e_cal_component_free_attendee_list (attendee_list);
g_list_free (destinations);
if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dialog->malarm_message)))
return;
/* Description */
text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (dialog->malarm_description));
gtk_text_buffer_get_start_iter (text_buffer, &text_iter_start);
gtk_text_buffer_get_end_iter (text_buffer, &text_iter_end);
str = gtk_text_buffer_get_text (text_buffer, &text_iter_start, &text_iter_end, FALSE);
description.value = str;
description.altrep = NULL;
e_cal_component_alarm_set_description (alarm, &description);
g_free (str);
/* remove the X-EVOLUTION-NEEDS-DESCRIPTION property, so that
* we don't re-set the alarm's description */
icalcomp = e_cal_component_alarm_get_icalcomponent (alarm);
icalprop = icalcomponent_get_first_property (icalcomp, ICAL_X_PROPERTY);
while (icalprop) {
const gchar *x_name;
x_name = icalproperty_get_x_name (icalprop);
if (!strcmp (x_name, "X-EVOLUTION-NEEDS-DESCRIPTION")) {
icalcomponent_remove_property (icalcomp, icalprop);
break;
}
icalprop = icalcomponent_get_next_property (icalcomp, ICAL_X_PROPERTY);
}
}
/**
* e_cal_util_split_at_instance:
* @icalcomp: A (recurring) #icalcomponent
* @rid: The base RECURRENCE-ID to remove
* @master_dtstart: The DTSTART of the master object
*
* Splits a recurring @icalcomp into two at time @rid. The returned icalcomponent
* is modified @icalcomp which contains recurrences beginning at @rid, inclusive.
* The instance identified by @rid should exist. The @master_dtstart can be
* a null time, then it is read from the @icalcomp.
*
* Use e_cal_util_remove_instances() with E_CAL_OBJ_MOD_THIS_AND_FUTURE mode
* on the @icalcomp to remove the overlapping interval from it, if needed.
*
* Returns: the split icalcomponent, or %NULL.
*
* Since: 3.16
**/
icalcomponent *
e_cal_util_split_at_instance (icalcomponent *icalcomp,
struct icaltimetype rid,
struct icaltimetype master_dtstart)
{
icalproperty *prop;
struct instance_data instance;
struct icaltimetype start, end;
struct icaldurationtype duration;
GSList *remove_props = NULL, *link;
g_return_val_if_fail (icalcomp != NULL, NULL);
g_return_val_if_fail (!icaltime_is_null_time (rid), NULL);
/* Make sure this is really recurring */
if (!icalcomponent_get_first_property (icalcomp, ICAL_RRULE_PROPERTY) &&
!icalcomponent_get_first_property (icalcomp, ICAL_RDATE_PROPERTY))
return NULL;
/* Make sure the specified instance really exists */
start = icaltime_convert_to_zone (rid, icaltimezone_get_utc_timezone ());
end = start;
icaltime_adjust (&end, 0, 0, 0, 1);
instance.start = icaltime_as_timet (start);
instance.found = FALSE;
icalcomponent_foreach_recurrence (icalcomp, start, end,
check_instance, &instance);
/* Make the copy */
icalcomp = icalcomponent_new_clone (icalcomp);
e_cal_util_remove_instances_ex (icalcomp, rid, E_CAL_OBJ_MOD_THIS_AND_PRIOR, TRUE, FALSE);
start = rid;
if (icaltime_is_null_time (master_dtstart))
master_dtstart = icalcomponent_get_dtstart (icalcomp);
duration = icalcomponent_get_duration (icalcomp);
/* Expect that DTSTART and DTEND are already set when the instance could not be found */
if (instance.found) {
icalcomponent_set_dtstart (icalcomp, start);
/* Update either DURATION or DTEND */
if (icaltime_is_null_time (icalcomponent_get_dtend (icalcomp))) {
icalcomponent_set_duration (icalcomp, duration);
} else {
end = start;
if (duration.is_neg)
icaltime_adjust (&end, -duration.days - 7 * duration.weeks, -duration.hours, -duration.minutes, -duration.seconds);
else
icaltime_adjust (&end, duration.days + 7 * duration.weeks, duration.hours, duration.minutes, duration.seconds);
icalcomponent_set_dtend (icalcomp, end);
}
}
/* any RRULE with 'count' should be shortened */
for (prop = icalcomponent_get_first_property (icalcomp, ICAL_RRULE_PROPERTY);
prop;
prop = icalcomponent_get_next_property (icalcomp, ICAL_RRULE_PROPERTY)) {
struct icaltimetype recur;
struct icalrecurrencetype rule;
rule = icalproperty_get_rrule (prop);
if (rule.count != 0) {
gint occurrences_count = 0;
icalrecur_iterator *iter;
iter = icalrecur_iterator_new (rule, master_dtstart);
while (recur = icalrecur_iterator_next (iter), !icaltime_is_null_time (recur) && occurrences_count < rule.count) {
if (icaltime_compare (recur, rid) >= 0)
break;
occurrences_count++;
}
icalrecur_iterator_free (iter);
if (icaltime_is_null_time (recur)) {
remove_props = g_slist_prepend (remove_props, prop);
} else {
rule.count -= occurrences_count;
icalproperty_set_rrule (prop, rule);
icalproperty_remove_parameter_by_name (prop, "X-EVOLUTION-ENDDATE");
}
}
}
for (link = remove_props; link; link = g_slist_next (link)) {
prop = link->data;
icalcomponent_remove_property (icalcomp, prop);
}
g_slist_free (remove_props);
return icalcomp;
}
static void
e_cal_util_remove_instances_ex (icalcomponent *icalcomp,
struct icaltimetype rid,
ECalObjModType mod,
gboolean keep_rid,
gboolean can_add_exrule)
{
icalproperty *prop;
struct icaltimetype itt, recur;
struct icalrecurrencetype rule;
icalrecur_iterator *iter;
GSList *remove_props = NULL, *rrules = NULL, *link;
g_return_if_fail (icalcomp != NULL);
g_return_if_fail (mod != E_CAL_OBJ_MOD_ALL);
/* First remove RDATEs and EXDATEs in the indicated range. */
for (prop = icalcomponent_get_first_property (icalcomp, ICAL_RDATE_PROPERTY);
prop;
prop = icalcomponent_get_next_property (icalcomp, ICAL_RDATE_PROPERTY)) {
struct icaldatetimeperiodtype period;
period = icalproperty_get_rdate (prop);
if (time_matches_rid (period.time, rid, mod) && (!keep_rid ||
icaltime_compare (period.time, rid) != 0))
remove_props = g_slist_prepend (remove_props, prop);
}
for (prop = icalcomponent_get_first_property (icalcomp, ICAL_EXDATE_PROPERTY);
prop;
prop = icalcomponent_get_next_property (icalcomp, ICAL_EXDATE_PROPERTY)) {
itt = icalproperty_get_exdate (prop);
if (time_matches_rid (itt, rid, mod) && (!keep_rid ||
icaltime_compare (itt, rid) != 0))
remove_props = g_slist_prepend (remove_props, prop);
}
for (link = remove_props; link; link = g_slist_next (link)) {
prop = link->data;
icalcomponent_remove_property (icalcomp, prop);
}
g_slist_free (remove_props);
remove_props = NULL;
/* If we're only removing one instance, just add an EXDATE. */
if (mod == E_CAL_OBJ_MOD_THIS) {
prop = icalproperty_new_exdate (rid);
icalcomponent_add_property (icalcomp, prop);
return;
}
/* Otherwise, iterate through RRULEs */
/* FIXME: this may generate duplicate EXRULEs */
for (prop = icalcomponent_get_first_property (icalcomp, ICAL_RRULE_PROPERTY);
prop;
prop = icalcomponent_get_next_property (icalcomp, ICAL_RRULE_PROPERTY)) {
rrules = g_slist_prepend (rrules, prop);
}
for (link = rrules; link; link = g_slist_next (link)) {
prop = link->data;
rule = icalproperty_get_rrule (prop);
iter = icalrecur_iterator_new (rule, rid);
recur = icalrecur_iterator_next (iter);
if (mod & E_CAL_OBJ_MOD_THIS_AND_FUTURE) {
/* Truncate the rule at rid. */
if (!icaltime_is_null_time (recur)) {
/* Use count if it was used */
if (rule.count > 0) {
gint occurrences_count = 0;
icalrecur_iterator *count_iter;
struct icaltimetype count_recur;
count_iter = icalrecur_iterator_new (rule, icalcomponent_get_dtstart (icalcomp));
while (count_recur = icalrecur_iterator_next (count_iter), !icaltime_is_null_time (count_recur) && occurrences_count < rule.count) {
if (icaltime_compare (count_recur, rid) >= 0)
break;
occurrences_count++;
}
icalrecur_iterator_free (count_iter);
if (keep_rid && icaltime_compare (count_recur, rid) == 0)
occurrences_count++;
/* The caller should make sure that the remove will keep at least one instance */
g_warn_if_fail (occurrences_count > 0);
rule.count = occurrences_count;
} else {
if (keep_rid && icaltime_compare (recur, rid) == 0)
rule.until = icaltime_add (rid, icalcomponent_get_duration (icalcomp));
else
rule.until = rid;
icaltime_adjust (&rule.until, 0, 0, 0, -1);
}
icalproperty_set_rrule (prop, rule);
icalproperty_remove_parameter_by_name (prop, "X-EVOLUTION-ENDDATE");
}
} else {
/* (If recur == rid, skip to the next occurrence) */
if (!keep_rid && icaltime_compare (recur, rid) == 0)
recur = icalrecur_iterator_next (iter);
/* If there is a recurrence after rid, add
* an EXRULE to block instances up to rid.
* Otherwise, just remove the RRULE.
*/
if (!icaltime_is_null_time (recur)) {
if (can_add_exrule) {
rule.count = 0;
/* iCalendar says we should just use rid
* here, but Outlook/Exchange handle
* UNTIL incorrectly.
*/
if (keep_rid && icaltime_compare (recur, rid) == 0) {
struct icaldurationtype duration = icalcomponent_get_duration (icalcomp);
duration.is_neg = !duration.is_neg;
rule.until = icaltime_add (rid, duration);
} else
rule.until = icaltime_add (rid, icalcomponent_get_duration (icalcomp));
prop = icalproperty_new_exrule (rule);
icalcomponent_add_property (icalcomp, prop);
}
} else {
remove_props = g_slist_prepend (remove_props, prop);
}
}
icalrecur_iterator_free (iter);
}
for (link = remove_props; link; link = g_slist_next (link)) {
prop = link->data;
icalcomponent_remove_property (icalcomp, prop);
}
g_slist_free (remove_props);
g_slist_free (rrules);
}
icalcomponent *icalparser_add_line(icalparser *parser, char *line)
{
char *str;
char *end;
int pcount = 0;
int vcount = 0;
icalproperty *prop;
icalproperty_kind prop_kind;
icalvalue *value;
icalvalue_kind value_kind = ICAL_NO_VALUE;
icalerror_check_arg_rz((parser != 0), "parser");
if (line == 0) {
parser->state = ICALPARSER_ERROR;
return 0;
}
if (line_is_blank(line) == 1) {
return 0;
}
/* Begin by getting the property name at the start of the line. The
property name may end up being "BEGIN" or "END" in which case it
is not really a property, but the marker for the start or end of
a component */
end = 0;
str = parser_get_prop_name(line, &end);
if (str == 0 || *str == '\0') {
/* Could not get a property name */
icalcomponent *tail = pvl_data(pvl_tail(parser->components));
if (tail) {
insert_error(
tail, line,
"Got a data line, but could not find a property name or component begin tag",
ICAL_XLICERRORTYPE_COMPONENTPARSEERROR);
}
tail = 0;
parser->state = ICALPARSER_ERROR;
icalmemory_free_buffer(str);
str = NULL;
return 0;
}
/**********************************************************************
* Handle begin and end of components
**********************************************************************/
/* If the property name is BEGIN or END, we are actually
starting or ending a new component */
if (strcasecmp(str, "BEGIN") == 0) {
icalcomponent *c;
icalcomponent_kind comp_kind;
parser->level++;
icalmemory_free_buffer(str);
str = parser_get_next_value(end, &end, value_kind);
comp_kind = icalenum_string_to_component_kind(str);
c = icalcomponent_new(comp_kind);
if (c == 0) {
c = icalcomponent_new(ICAL_XLICINVALID_COMPONENT);
insert_error(c, str, "Parse error in component name",
ICAL_XLICERRORTYPE_COMPONENTPARSEERROR);
}
pvl_push(parser->components, c);
parser->state = ICALPARSER_BEGIN_COMP;
icalmemory_free_buffer(str);
str = NULL;
return 0;
} else if (strcasecmp(str, "END") == 0) {
icalcomponent *tail;
parser->level--;
icalmemory_free_buffer(str);
str = parser_get_next_value(end, &end, value_kind);
/* Pop last component off of list and add it to the second-to-last */
parser->root_component = pvl_pop(parser->components);
tail = pvl_data(pvl_tail(parser->components));
if (tail != 0) {
icalcomponent_add_component(tail, parser->root_component);
}
tail = 0;
icalmemory_free_buffer(str);
str = NULL;
if (parser->level < 0) {
// Encountered an END before any BEGIN, this must be invalid data
icalerror_warn("Encountered END before BEGIN");
parser->state = ICALPARSER_ERROR;
parser->level = 0;
return 0;
} else if (parser->level == 0) {
/* Return the component if we are back to the 0th level */
icalcomponent *rtrn;
if (pvl_count(parser->components) != 0) {
/* There are still components on the stack -- this means
that one of them did not have a proper "END" */
pvl_push(parser->components, parser->root_component);
(void)icalparser_clean(parser); /* may reset parser->root_component */
}
assert(pvl_count(parser->components) == 0);
parser->state = ICALPARSER_SUCCESS;
rtrn = parser->root_component;
parser->root_component = 0;
return rtrn;
} else {
parser->state = ICALPARSER_END_COMP;
return 0;
}
}
/* There is no point in continuing if we have not seen a
component yet */
if (pvl_data(pvl_tail(parser->components)) == 0) {
parser->state = ICALPARSER_ERROR;
icalmemory_free_buffer(str);
str = NULL;
return 0;
}
/**********************************************************************
* Handle property names
**********************************************************************/
/* At this point, the property name really is a property name,
(Not a component name) so make a new property and add it to
the component */
prop_kind = icalproperty_string_to_kind(str);
prop = icalproperty_new(prop_kind);
if (prop != 0) {
icalcomponent *tail = pvl_data(pvl_tail(parser->components));
if (prop_kind == ICAL_X_PROPERTY) {
icalproperty_set_x_name(prop, str);
}
icalcomponent_add_property(tail, prop);
/* Set the value kind for the default for this type of
property. This may be re-set by a VALUE parameter */
value_kind = icalproperty_kind_to_value_kind(icalproperty_isa(prop));
} else {
icalcomponent *tail = pvl_data(pvl_tail(parser->components));
insert_error(tail, str, "Parse error in property name",
ICAL_XLICERRORTYPE_PROPERTYPARSEERROR);
tail = 0;
parser->state = ICALPARSER_ERROR;
icalmemory_free_buffer(str);
str = NULL;
return 0;
}
icalmemory_free_buffer(str);
str = NULL;
/**********************************************************************
* Handle parameter values
**********************************************************************/
/* Now, add any parameters to the last property */
while (pcount < MAXIMUM_ALLOWED_PARAMETERS) {
if (*(end - 1) == ':') {
/* if the last separator was a ":" and the value is a
URL, icalparser_get_next_parameter will find the
':' in the URL, so better break now. */
break;
}
icalmemory_free_buffer(str);
str = parser_get_next_parameter(end, &end);
strstriplt(str);
if (str != 0) {
char *name_heap = 0;
char *pvalue_heap = 0;
char name_stack[TMP_BUF_SIZE];
char pvalue_stack[TMP_BUF_SIZE];
char *name = name_stack;
char *pvalue = pvalue_stack;
icalparameter *param = 0;
icalparameter_kind kind;
icalcomponent *tail = pvl_data(pvl_tail(parser->components));
if (!parser_get_param_name_stack(str, name_stack, sizeof(name_stack),
pvalue_stack, sizeof(pvalue_stack))) {
name_heap = parser_get_param_name_heap(str, &pvalue_heap);
name = name_heap;
pvalue = pvalue_heap;
if (name_heap == 0) {
/* 'tail' defined above */
insert_error(tail, str, "Cant parse parameter name",
ICAL_XLICERRORTYPE_PARAMETERNAMEPARSEERROR);
tail = 0;
break;
}
}
kind = icalparameter_string_to_kind(name);
if (kind == ICAL_X_PARAMETER) {
param = icalparameter_new(ICAL_X_PARAMETER);
if (param != 0) {
icalparameter_set_xname(param, name);
icalparameter_set_xvalue(param, pvalue);
}
} else if (kind == ICAL_IANA_PARAMETER) {
ical_unknown_token_handling tokHandlingSetting =
ical_get_unknown_token_handling_setting();
if (tokHandlingSetting == ICAL_DISCARD_TOKEN) {
if (name_heap) {
icalmemory_free_buffer(name_heap);
name_heap = 0;
}
if (pvalue_heap) {
icalmemory_free_buffer(pvalue_heap);
pvalue_heap = 0;
}
continue;
}
param = icalparameter_new(ICAL_IANA_PARAMETER);
if (param != 0) {
icalparameter_set_xname(param, name);
icalparameter_set_xvalue(param, pvalue);
}
} else if (kind == ICAL_TZID_PARAMETER && *(end - 1) != ';') {
/*
Special case handling for TZID to work around invalid incoming data.
For example, Google Calendar will send back stuff like this:
DTSTART;TZID=GMT+05:30:20120904T020000
In this case we read to the next semicolon or the last colon rather
than the first colon. This way the TZID will become GMT+05:30 rather
than trying to parse the date-time as 30:20120904T020000.
This also handles properties that look like this:
DTSTART;TZID=GMT+05:30;VALUE=DATE-TIME:20120904T020000
*/
char *lastColon = 0;
char *nextColon = end;
char *nextSemicolon = parser_get_next_char(';', end, 1);
/* Find the last colon in the line */
do {
nextColon = parser_get_next_char(':', nextColon, 1);
if (nextColon) {
lastColon = nextColon;
}
} while (nextColon);
if (lastColon && nextSemicolon && nextSemicolon < lastColon) {
/*
Ensures that we don't read past a semicolon
Handles the following line:
DTSTART;TZID=GMT+05:30;VALUE=DATE-TIME:20120904T020000
*/
lastColon = nextSemicolon;
}
/*
Rebuild str so that it includes everything up to the next semicolon
or the last colon. So given the above example, str will go from
"TZID=GMT+05" to "TZID=GMT+05:30"
*/
if (lastColon && *(lastColon + 1) != 0) {
char *strStart = line + strlen(name) + 2;
end = lastColon + 1;
icalmemory_free_buffer(str);
str = make_segment(strStart, end - 1);
}
/* Reparse the parameter name and value with the new segment */
if (!parser_get_param_name_stack(str, name_stack, sizeof(name_stack),
pvalue_stack, sizeof(pvalue_stack))) {
if (pvalue_heap) {
icalmemory_free_buffer(pvalue_heap);
pvalue_heap = 0;
pvalue = 0;
}
if (name_heap) {
icalmemory_free_buffer(name_heap);
name = 0;
}
name_heap = parser_get_param_name_heap(str, &pvalue_heap);
pvalue = pvalue_heap;
}
param = icalparameter_new_from_value_string(kind, pvalue);
} else if (kind != ICAL_NO_PARAMETER) {
param = icalparameter_new_from_value_string(kind, pvalue);
} else {
/* Error. Failed to parse the parameter */
/* 'tail' defined above */
/* Change for mozilla */
/* have the option of being flexible towards unsupported parameters */
#if ICAL_ERRORS_ARE_FATAL == 1
insert_error(tail, str, "Cant parse parameter name",
ICAL_XLICERRORTYPE_PARAMETERNAMEPARSEERROR);
tail = 0;
parser->state = ICALPARSER_ERROR;
if (pvalue_heap) {
icalmemory_free_buffer(pvalue_heap);
pvalue = 0;
}
if (name_heap) {
icalmemory_free_buffer(name_heap);
name = 0;
}
icalmemory_free_buffer(str);
str = NULL;
return 0;
#else
if (name_heap) {
icalmemory_free_buffer(name_heap);
name_heap = 0;
}
if (pvalue_heap) {
icalmemory_free_buffer(pvalue_heap);
pvalue_heap = 0;
}
icalmemory_free_buffer(str);
str = NULL;
continue;
#endif
}
if (pvalue_heap) {
icalmemory_free_buffer(pvalue_heap);
pvalue_heap = 0;
}
if (name_heap) {
icalmemory_free_buffer(name_heap);
name_heap = 0;
}
if (param == 0) {
/* 'tail' defined above */
insert_error(tail, str, "Cant parse parameter value",
ICAL_XLICERRORTYPE_PARAMETERVALUEPARSEERROR);
tail = 0;
parser->state = ICALPARSER_ERROR;
icalmemory_free_buffer(str);
str = NULL;
continue;
}
/* If it is a VALUE parameter, set the kind of value */
if (icalparameter_isa(param) == ICAL_VALUE_PARAMETER) {
value_kind =
(icalvalue_kind)icalparameter_value_to_value_kind(
icalparameter_get_value(param));
if (!icalproperty_value_kind_is_valid(prop_kind, value_kind)) {
/* Ooops, invalid VALUE parameter, so reset the value_kind */
const char *err_str = "Invalid VALUE type for property";
const char *prop_str = icalproperty_kind_to_string(prop_kind);
size_t tmp_buf_len = strlen(err_str) + strlen(prop_str) + 2;
char *tmp_buf = icalmemory_tmp_buffer(tmp_buf_len);
snprintf(tmp_buf, tmp_buf_len, "%s %s", err_str, prop_str);
insert_error(tail, str, tmp_buf,
ICAL_XLICERRORTYPE_PARAMETERVALUEPARSEERROR);
value_kind = icalproperty_kind_to_value_kind(prop_kind);
icalparameter_free(param);
tail = 0;
parser->state = ICALPARSER_ERROR;
icalmemory_free_buffer(str);
str = NULL;
pcount++;
continue;
}
}
/* Everything is OK, so add the parameter */
icalproperty_add_parameter(prop, param);
tail = 0;
icalmemory_free_buffer(str);
str = NULL;
pcount++;
} else {
/* str is NULL */
break;
}
} /* while(1) */
/**********************************************************************
* Handle values
**********************************************************************/
/* Look for values. If there are ',' characters in the values,
then there are multiple values, so clone the current
parameter and add one part of the value to each clone */
vcount = 0;
while (vcount < MAXIMUM_ALLOWED_MULTIPLE_VALUES) {
/* Only some properties can have multiple values. This list was taken
from rfc5545. Also added the x-properties, because the spec actually
says that commas should be escaped. For x-properties, other apps may
depend on that behaviour
*/
icalmemory_free_buffer(str);
str = NULL;
if (icalproperty_value_kind_is_multivalued(prop_kind, &value_kind)) {
str = parser_get_next_value(end, &end, value_kind);
} else {
str = icalparser_get_value(end, &end, value_kind);
}
strstriplt(str);
if (str != 0) {
if (vcount > 0) {
/* Actually, only clone after the second value */
icalproperty *clone = icalproperty_clone(prop);
icalcomponent *tail = pvl_data(pvl_tail(parser->components));
icalcomponent_add_property(tail, clone);
prop = clone;
tail = 0;
}
value = icalvalue_new_from_string(value_kind, str);
/* Don't add properties without value */
if (value == 0) {
char temp[200]; /* HACK */
icalproperty_kind prop_kind = icalproperty_isa(prop);
icalcomponent *tail = pvl_data(pvl_tail(parser->components));
snprintf(temp, sizeof(temp),
"Can't parse as %s value in %s property. Removing entire property",
icalvalue_kind_to_string(value_kind),
icalproperty_kind_to_string(prop_kind));
insert_error(tail, str, temp, ICAL_XLICERRORTYPE_VALUEPARSEERROR);
/* Remove the troublesome property */
icalcomponent_remove_property(tail, prop);
icalproperty_free(prop);
prop = 0;
tail = 0;
parser->state = ICALPARSER_ERROR;
icalmemory_free_buffer(str);
str = NULL;
return 0;
} else {
vcount++;
icalproperty_set_value(prop, value);
}
icalmemory_free_buffer(str);
str = NULL;
} else {
#if ICAL_ALLOW_EMPTY_PROPERTIES
/* Don't replace empty properties with an error.
Set an empty length string (not null) as the value instead */
if (vcount == 0) {
icalproperty_set_value(prop, icalvalue_new(ICAL_NO_VALUE));
}
break;
#else
if (vcount == 0) {
char temp[200]; /* HACK */
icalproperty_kind prop_kind = icalproperty_isa(prop);
icalcomponent *tail = pvl_data(pvl_tail(parser->components));
snprintf(temp, sizeof(temp), "No value for %s property. Removing entire property",
icalproperty_kind_to_string(prop_kind));
insert_error(tail, str, temp, ICAL_XLICERRORTYPE_VALUEPARSEERROR);
/* Remove the troublesome property */
icalcomponent_remove_property(tail, prop);
icalproperty_free(prop);
prop = 0;
tail = 0;
parser->state = ICALPARSER_ERROR;
return 0;
} else {
break;
}
#endif
}
}
/****************************************************************
* End of component parsing.
*****************************************************************/
if (pvl_data(pvl_tail(parser->components)) == 0 && parser->level == 0) {
/* HACK. Does this clause ever get executed? */
parser->state = ICALPARSER_SUCCESS;
assert(0);
return parser->root_component;
} else {
parser->state = ICALPARSER_IN_PROGRESS;
return 0;
}
}
icalcomponent* icalparser_add_line(icalparser* parser,
char* line)
{
char *str;
char *end;
int vcount = 0;
icalproperty *prop;
icalproperty_kind prop_kind;
icalvalue *value;
icalvalue_kind value_kind = ICAL_NO_VALUE;
icalerror_check_arg_rz((parser != 0),"parser");
if (line == 0)
{
parser->state = ICALPARSER_ERROR;
return 0;
}
if(line_is_blank(line) == 1){
return 0;
}
/* Begin by getting the property name at the start of the line. The
property name may end up being "BEGIN" or "END" in which case it
is not really a property, but the marker for the start or end of
a component */
end = 0;
str = parser_get_prop_name(line, &end);
if (str == 0 || *str == '\0' ){
/* Could not get a property name */
icalcomponent *tail = pvl_data(pvl_tail(parser->components));
if (tail){
insert_error(tail,line,
"Got a data line, but could not find a property name or component begin tag",
ICAL_XLICERRORTYPE_COMPONENTPARSEERROR);
}
tail = 0;
parser->state = ICALPARSER_ERROR;
icalmemory_free_buffer(str);
str = NULL;
return 0;
}
/**********************************************************************
* Handle begin and end of components
**********************************************************************/
/* If the property name is BEGIN or END, we are actually
starting or ending a new component */
if(strcasecmp(str,"BEGIN") == 0){
icalcomponent *c;
icalcomponent_kind comp_kind;
icalmemory_free_buffer(str);
str = NULL;
parser->level++;
str = parser_get_next_value(end,&end, value_kind);
comp_kind = icalenum_string_to_component_kind(str);
if (comp_kind == ICAL_NO_COMPONENT){
c = icalcomponent_new(ICAL_XLICINVALID_COMPONENT);
insert_error(c,str,"Parse error in component name",
ICAL_XLICERRORTYPE_COMPONENTPARSEERROR);
}
c = icalcomponent_new(comp_kind);
if (c == 0){
c = icalcomponent_new(ICAL_XLICINVALID_COMPONENT);
insert_error(c,str,"Parse error in component name",
ICAL_XLICERRORTYPE_COMPONENTPARSEERROR);
}
pvl_push(parser->components,c);
parser->state = ICALPARSER_BEGIN_COMP;
icalmemory_free_buffer(str);
str = NULL;
return 0;
} else if (strcasecmp(str,"END") == 0 ) {
icalcomponent* tail;
icalmemory_free_buffer(str);
str = NULL;
parser->level--;
str = parser_get_next_value(end,&end, value_kind);
/* Pop last component off of list and add it to the second-to-last*/
parser->root_component = pvl_pop(parser->components);
tail = pvl_data(pvl_tail(parser->components));
if(tail != 0){
icalcomponent_add_component(tail,parser->root_component);
}
tail = 0;
icalmemory_free_buffer(str);
str = NULL;
/* Return the component if we are back to the 0th level */
if (parser->level == 0){
icalcomponent *rtrn;
if(pvl_count(parser->components) != 0){
/* There are still components on the stack -- this means
that one of them did not have a proper "END" */
pvl_push(parser->components,parser->root_component);
icalparser_clean(parser); /* may reset parser->root_component*/
}
assert(pvl_count(parser->components) == 0);
parser->state = ICALPARSER_SUCCESS;
rtrn = parser->root_component;
parser->root_component = 0;
return rtrn;
} else {
parser->state = ICALPARSER_END_COMP;
return 0;
}
}
/* There is no point in continuing if we have not seen a
component yet */
if(pvl_data(pvl_tail(parser->components)) == 0){
parser->state = ICALPARSER_ERROR;
icalmemory_free_buffer(str);
str = NULL;
return 0;
}
/**********************************************************************
* Handle property names
**********************************************************************/
/* At this point, the property name really is a property name,
(Not a component name) so make a new property and add it to
the component */
prop_kind = icalproperty_string_to_kind(str);
prop = icalproperty_new(prop_kind);
if (prop != 0){
icalcomponent *tail = pvl_data(pvl_tail(parser->components));
if(prop_kind==ICAL_X_PROPERTY){
icalproperty_set_x_name(prop,str);
}
icalcomponent_add_property(tail, prop);
/* Set the value kind for the default for this type of
property. This may be re-set by a VALUE parameter */
value_kind = icalproperty_kind_to_value_kind(icalproperty_isa(prop));
} else {
icalcomponent* tail = pvl_data(pvl_tail(parser->components));
insert_error(tail,str,"Parse error in property name",
ICAL_XLICERRORTYPE_PROPERTYPARSEERROR);
tail = 0;
parser->state = ICALPARSER_ERROR;
icalmemory_free_buffer(str);
str = NULL;
return 0;
}
icalmemory_free_buffer(str);
str = NULL;
/**********************************************************************
* Handle parameter values
**********************************************************************/
/* Now, add any parameters to the last property */
while(1) {
if (*(end-1) == ':'){
/* if the last separator was a ":" and the value is a
URL, icalparser_get_next_parameter will find the
':' in the URL, so better break now. */
break;
}
str = parser_get_next_parameter(end,&end);
strstriplt(str);
if (str != 0){
char* name = 0;
char* pvalue = 0;
char *buf_value = NULL;
icalparameter *param = 0;
icalparameter_kind kind;
icalcomponent *tail = pvl_data(pvl_tail(parser->components));
name = parser_get_param_name(str,&pvalue,&buf_value);
if (name == 0){
/* 'tail' defined above */
insert_error(tail, str, "Cant parse parameter name",
ICAL_XLICERRORTYPE_PARAMETERNAMEPARSEERROR);
tail = 0;
break;
}
kind = icalparameter_string_to_kind(name);
if(kind == ICAL_X_PARAMETER){
param = icalparameter_new(ICAL_X_PARAMETER);
if(param != 0){
icalparameter_set_xname(param,name);
icalparameter_set_xvalue(param,pvalue);
}
icalmemory_free_buffer(buf_value);
buf_value = NULL;
} else if (kind != ICAL_NO_PARAMETER){
param = icalparameter_new_from_value_string(kind,pvalue);
icalmemory_free_buffer(buf_value);
buf_value = NULL;
} else {
/* Error. Failed to parse the parameter*/
/* 'tail' defined above */
/* Change for mozilla */
/* have the option of being flexible towards unsupported parameters */
#ifndef ICAL_ERRORS_ARE_FATAL
continue;
#endif
insert_error(tail, str, "Cant parse parameter name",
ICAL_XLICERRORTYPE_PARAMETERNAMEPARSEERROR);
tail = 0;
parser->state = ICALPARSER_ERROR;
/* if (pvalue) {
free(pvalue);
pvalue = 0;
} */
if (name) {
free(name);
name = 0;
}
return 0;
}
/* if (pvalue) {
free(pvalue);
pvalue = 0;
} */
if (name) {
free(name);
name = 0;
}
if (param == 0){
/* 'tail' defined above */
insert_error(tail,str,"Cant parse parameter value",
ICAL_XLICERRORTYPE_PARAMETERVALUEPARSEERROR);
tail = 0;
parser->state = ICALPARSER_ERROR;
icalmemory_free_buffer(buf_value);
buf_value = NULL;
icalmemory_free_buffer(name);
name = NULL;
icalmemory_free_buffer(str);
str = NULL;
continue;
}
/* If it is a VALUE parameter, set the kind of value*/
if (icalparameter_isa(param)==ICAL_VALUE_PARAMETER){
value_kind = (icalvalue_kind)
icalparameter_value_to_value_kind(
icalparameter_get_value(param)
);
if (value_kind == ICAL_NO_VALUE){
/* Ooops, could not parse the value of the
parameter ( it was not one of the defined
values ), so reset the value_kind */
insert_error(
tail, str,
"Got a VALUE parameter with an unknown type",
ICAL_XLICERRORTYPE_PARAMETERVALUEPARSEERROR);
icalparameter_free(param);
value_kind =
icalproperty_kind_to_value_kind(
icalproperty_isa(prop));
icalparameter_free(param);
tail = 0;
parser->state = ICALPARSER_ERROR;
icalmemory_free_buffer(name);
name = NULL;
icalmemory_free_buffer(str);
str = NULL;
continue;
}
}
icalmemory_free_buffer(name);
name = NULL;
/* Everything is OK, so add the parameter */
icalproperty_add_parameter(prop,param);
tail = 0;
icalmemory_free_buffer(str);
str = NULL;
} else { /* if ( str != 0) */
/* If we did not get a param string, go on to looking for a value */
if (str != NULL) {
icalmemory_free_buffer(str);
str = NULL;
}
break;
} /* if ( str != 0) */
} /* while(1) */
/**********************************************************************
* Handle values
**********************************************************************/
/* Look for values. If there are ',' characters in the values,
then there are multiple values, so clone the current
parameter and add one part of the value to each clone */
vcount=0;
while(1) {
/* Only some properies can have multiple values. This list was taken
from rfc2445. Also added the x-properties, because the spec actually
says that commas should be escaped. For x-properties, other apps may
depend on that behaviour
*/
switch (prop_kind) {
case ICAL_X_PROPERTY:
case ICAL_CATEGORIES_PROPERTY:
case ICAL_RESOURCES_PROPERTY:
/* Referring to RFC 2445, section 4.8.5.3 and section 4.8.5.1:
RDATE and EXDATE can specify a list of dates/date-times/periods.
*/
case ICAL_RDATE_PROPERTY:
case ICAL_EXDATE_PROPERTY:
/* Referring to RFC 2445, section 4.8.2.6 Free/Busy Time:
The "FREEBUSY" property can specify more than one value, separated by
the COMMA character (US-ASCII decimal 44).
*/
case ICAL_FREEBUSY_PROPERTY:
str = parser_get_next_value(end,&end, value_kind);
strstriplt (str);
break;
default:
str = icalparser_get_value(end, &end, value_kind);
strstriplt (str);
break;
}
if (str != 0){
if (vcount > 0){
/* Actually, only clone after the second value */
icalproperty* clone = icalproperty_new_clone(prop);
icalcomponent* tail = pvl_data(pvl_tail(parser->components));
icalcomponent_add_property(tail, clone);
prop = clone;
tail = 0;
}
value = icalvalue_new_from_string(value_kind, str);
/* Don't add properties without value */
if (value == 0){
char temp[200]; /* HACK */
icalproperty_kind prop_kind = icalproperty_isa(prop);
icalcomponent* tail = pvl_data(pvl_tail(parser->components));
snprintf(temp,sizeof(temp),"Can't parse as %s value in %s property. Removing entire property",
icalvalue_kind_to_string(value_kind),
icalproperty_kind_to_string(prop_kind));
insert_error(tail, str, temp,
ICAL_XLICERRORTYPE_VALUEPARSEERROR);
/* Remove the troublesome property */
icalcomponent_remove_property(tail,prop);
icalproperty_free(prop);
prop = 0;
tail = 0;
parser->state = ICALPARSER_ERROR;
icalmemory_free_buffer(str);
str = NULL;
return 0;
} else {
vcount++;
icalproperty_set_value(prop, value);
}
icalmemory_free_buffer(str);
str = NULL;
} else {
if (str != NULL) {
icalmemory_free_buffer(str);
str = NULL;
}
if (vcount == 0){
char temp[200]; /* HACK */
icalproperty_kind prop_kind = icalproperty_isa(prop);
icalcomponent *tail = pvl_data(pvl_tail(parser->components));
snprintf(temp,sizeof(temp),"No value for %s property. Removing entire property",
icalproperty_kind_to_string(prop_kind));
insert_error(tail, str, temp,
ICAL_XLICERRORTYPE_VALUEPARSEERROR);
/* Remove the troublesome property */
icalcomponent_remove_property(tail,prop);
icalproperty_free(prop);
prop = 0;
tail = 0;
parser->state = ICALPARSER_ERROR;
return 0;
} else {
break;
}
}
}
/****************************************************************
* End of component parsing.
*****************************************************************/
if (pvl_data(pvl_tail(parser->components)) == 0 &&
parser->level == 0){
/* HACK. Does this clause ever get executed? */
parser->state = ICALPARSER_SUCCESS;
assert(0);
return parser->root_component;
} else {
parser->state = ICALPARSER_IN_PROGRESS;
return 0;
}
}
icaltimezone *
calendar_config_get_icaltimezone (void)
{
char *location;
icaltimezone *zone = NULL;
calendar_config_init ();
location = calendar_config_get_timezone ();
if (location) {
icalcomponent *icalcomp, *dl_comp;
zone = icaltimezone_get_builtin_timezone (location);
icalcomp = icaltimezone_get_component (zone);
if (!(dl_comp = icalcomponent_get_first_component (icalcomp, ICAL_XDAYLIGHT_COMPONENT))) {
g_free (location);
return zone;
}
if (!calendar_config_get_daylight_saving () && zone) {
icalcomponent *zone_comp, *s_comp;
icalproperty *tz_prop, *offset_to;
icaltimezone *st_zone = NULL;
int offset;
char *n_tzid, *tzid;
tzid = icaltimezone_get_tzid (zone);
n_tzid = g_strconcat (tzid, "-(Standard)", NULL);
if (!custom_zones) {
custom_zones = g_hash_table_new (g_str_hash, g_str_equal);
} else if ((st_zone = g_hash_table_lookup (custom_zones, n_tzid))) {
g_free (n_tzid);
g_free (location);
return st_zone;
}
zone_comp = icalcomponent_new_clone (icalcomp);
s_comp = icalcomponent_get_first_component (zone_comp, ICAL_XSTANDARD_COMPONENT);
if (!s_comp) {
g_free (n_tzid);
icalcomponent_free (zone_comp);
g_free (location);
return zone;
}
offset_to = icalcomponent_get_first_property (s_comp, ICAL_TZOFFSETTO_PROPERTY);
offset = icalproperty_get_tzoffsetto (offset_to);
set_standard_offsets (zone_comp, offset);
tz_prop = icalcomponent_get_first_property (zone_comp, ICAL_TZID_PROPERTY);
if (tz_prop) {
icalcomponent_remove_property (zone_comp, tz_prop);
}
tz_prop = icalproperty_new_tzid (n_tzid);
icalcomponent_add_property (zone_comp, tz_prop);
st_zone = icaltimezone_new ();
icaltimezone_set_component (st_zone, zone_comp);
zone = st_zone;
g_hash_table_insert (custom_zones, n_tzid, zone);
}
g_free (location);
}
return zone;
}
