aboutsummaryrefslogtreecommitdiffstats
path: root/libical
diff options
context:
space:
mode:
Diffstat (limited to 'libical')
-rw-r--r--libical/ChangeLog8
-rw-r--r--libical/src/libical/icalcomponent.c410
-rw-r--r--libical/src/libical/icalcomponent.h24
-rw-r--r--libical/src/libical/icaltime.c222
-rw-r--r--libical/src/libical/icaltime.h28
-rw-r--r--libical/src/libical/icaltimezone.c439
-rw-r--r--libical/src/libical/icaltimezone.h41
7 files changed, 863 insertions, 309 deletions
diff --git a/libical/ChangeLog b/libical/ChangeLog
index b6c275ff2d..a86513c7ab 100644
--- a/libical/ChangeLog
+++ b/libical/ChangeLog
@@ -1,3 +1,9 @@
+2001-07-03 Damon Chaplin <damon@ximian.com>
+
+ * src/libical/icaltimezone.c (icaltimezone_get_builtin_timezone_from_tzid):
+ * src/libical/icaltime.c:
+ * src/libical/icalcomponent.c: more timezone stuff.
+
2001-06-28 Peter Williams <peterw@ximian.com>
* zoneinfo/Makefile.am (dist-hook): Add $(srcdir) as in install-data-local
@@ -7,7 +13,7 @@
* configure.in: commented out AC_DEFINE(ICAL_ERRORS_ARE_FATAL,1).
We only want it to abort when there is no possibility of carrying on.
-
+
2001-06-26 Damon Chaplin <damon@ximian.com>
* zoneinfo/*: stripped all blank lines from iCalendar files.
diff --git a/libical/src/libical/icalcomponent.c b/libical/src/libical/icalcomponent.c
index ee4ec54f30..8c5295b79f 100644
--- a/libical/src/libical/icalcomponent.c
+++ b/libical/src/libical/icalcomponent.c
@@ -44,6 +44,7 @@
#include <errno.h>
#include <assert.h>
#include <stdio.h> /* for fprintf */
+#include <string.h> /* for strdup */
#define MAX_TMP 1024
@@ -68,8 +69,22 @@ void icalcomponent_add_children(struct icalcomponent_impl *impl,va_list args);
icalcomponent* icalcomponent_new_impl (icalcomponent_kind kind);
int icalcomponent_property_sorter(void *a, void *b);
+static void icalcomponent_merge_vtimezone (icalcomponent *comp,
+ icalcomponent *vtimezone,
+ icalarray *tzids_to_rename);
+static void icalcomponent_handle_conflicting_vtimezones (icalcomponent *comp,
+ icalcomponent *vtimezone,
+ icalproperty *tzid_prop,
+ const char *tzid,
+ icalarray *tzids_to_rename);
+static int icalcomponent_get_tzid_prefix_len (const char *tzid);
+static void icalcomponent_rename_tzids(icalcomponent* comp,
+ icalarray* rename_table);
static void icalcomponent_rename_tzids_callback(icalparameter *param,
void *data);
+static int icalcomponent_compare_vtimezones (icalcomponent *vtimezone1,
+ icalcomponent *vtimezone2);
+
void icalcomponent_add_children(struct icalcomponent_impl *impl,va_list args)
{
@@ -704,58 +719,6 @@ icalcomponent* icalcomponent_get_first_real_component(icalcomponent *c)
return 0;
}
-time_t icalcomponent_convert_time(icalproperty *p)
-{
- struct icaltimetype sict;
- time_t convt;
- icalproperty *tzp;
-
-
- /* Though it says _dtstart, it will work for dtend too */
- sict = icalproperty_get_dtstart(p);
-
- tzp = icalproperty_get_first_parameter(p,ICAL_TZID_PARAMETER);
-
- if (sict.is_utc == 1 && tzp != 0){
- icalerror_warn("icalcomponent_get_span: component has a UTC DTSTART with a timezone specified ");
- icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
- return 0;
- }
-
- if(sict.is_utc == 1){
- /* _as_timet will use gmtime() to do the conversion */
- convt = icaltime_as_timet(sict);
-
-#ifdef TEST_CONVERT_TIME
- printf("convert time: use as_timet:\n %s\n %s",
- icalproperty_as_ical_string(p), ctime(&convt));
-#endif
-
- } else if (sict.is_utc == 0 && tzp == 0 ) {
- time_t offset;
-
- /* _as_timet will use localtime() to do the conversion */
- convt = icaltime_as_timet(sict);
- offset = icaltime_utc_offset(sict,0);
- convt += offset;
-
-#ifdef TEST_CONVERT_TIME
- printf("convert time: use as_timet and adjust:\n %s\n %s",
- icalproperty_as_ical_string(p), ctime(&convt));
-#endif
- } else {
- /* Convert the time to UTC for the named timezone*/
- const char* timezone = icalparameter_get_tzid(tzp);
- convt = icaltime_as_timet(icaltime_as_utc(sict,timezone));
-
-#ifdef TEST_CONVERT_TIME
- printf("convert time: use _as_utc:\n %s\n %s",
- icalproperty_as_ical_string(p), ctime(&convt));
-#endif
- }
-
- return convt;
-}
struct icaltime_span icalcomponent_get_span(icalcomponent* comp)
{
icalcomponent *inner;
@@ -822,7 +785,10 @@ struct icaltime_span icalcomponent_get_span(icalcomponent* comp)
icalerror_clear_errno();
+ /* FIXME: Needs updating to new icaltimezone functions. */
+#if 0
span.start = icalcomponent_convert_time(p);
+#endif
#ifdef TEST_CONVERT_TIME
printf("convert time:\n %s %s",
@@ -846,7 +812,10 @@ struct icaltime_span icalcomponent_get_span(icalcomponent* comp)
}
if (p!=0){
+ /* FIXME: Needs updating to new icaltimezone functions. */
+#if 0
span.end = icalcomponent_convert_time(p);
+#endif
} else if (start.is_date == 1) {
/* Duration is all day */
span.end = span.start + 60*60*24;
@@ -1514,47 +1483,220 @@ icalcomponent* icalcomponent_new_xdaylight()
return icalcomponent_new(ICAL_XDAYLIGHT_COMPONENT);
}
-/* Calls the given function for each TZID parameter found in the component. */
-void icalcomponent_foreach_tzid(icalcomponent* comp,
- void (*callback)(icalparameter *param, void *data),
- void *callback_data)
-{
- icalproperty *prop;
- icalproperty_kind kind;
- icalparameter *param;
- icalcomponent *child;
- /* First rename any TZID parameters used in this component. */
- prop = icalcomponent_get_first_property (comp, ICAL_ANY_PROPERTY);
- while (prop) {
- kind = icalproperty_isa (prop);
-
- /* These are the only properties that can have a TZID. Note that
- COMPLETED, CREATED, DTSTAMP & LASTMODIFIED must be in UTC. */
- if (kind == ICAL_DTSTART_PROPERTY || kind == ICAL_DTEND_PROPERTY
- || kind == ICAL_DUE_PROPERTY || kind == ICAL_EXDATE_PROPERTY
- || kind == ICAL_RDATE_PROPERTY) {
- param = icalproperty_get_first_parameter (prop, ICAL_TZID_PARAMETER);
- if (param)
- (*callback) (param, callback_data);
+/*
+ * Timezone stuff.
+ */
+
+/* This takes 2 VCALENDAR components and merges the second one into the first,
+ resolving any problems with conflicting TZIDs. comp_to_merge will no
+ longer exist after calling this function. */
+void icalcomponent_merge_component(icalcomponent* comp,
+ icalcomponent* comp_to_merge)
+{
+ icalcomponent *subcomp, *next_subcomp;
+ icalarray *tzids_to_rename;
+ int i;
+
+ /* Check that both components are VCALENDAR components. */
+ assert (icalcomponent_isa(comp) == ICAL_VCALENDAR_COMPONENT);
+ assert (icalcomponent_isa(comp_to_merge) != ICAL_VCALENDAR_COMPONENT);
+
+ /* Step through each subcomponent of comp_to_merge, looking for VTIMEZONEs.
+ For each VTIMEZONE found, check if we need to add it to comp and if we
+ need to rename it and all TZID references to it. */
+ tzids_to_rename = icalarray_new (sizeof (char*), 16);
+ subcomp = icalcomponent_get_first_component (comp_to_merge,
+ ICAL_VTIMEZONE_COMPONENT);
+ while (subcomp) {
+ next_subcomp = icalcomponent_get_next_component (comp_to_merge,
+ ICAL_VTIMEZONE_COMPONENT);
+ /* This will add the VTIMEZONE to comp, if necessary, and also update
+ the array of TZIDs we need to rename. */
+ icalcomponent_merge_vtimezone (comp, subcomp, tzids_to_rename);
+ /* FIXME: Handle possible NEWFAILED error. */
+
+ subcomp = next_subcomp;
+ }
+
+ /* If we need to do any renaming of TZIDs, do it now. */
+ if (tzids_to_rename->num_elements != 0) {
+ icalcomponent_rename_tzids (comp_to_merge, tzids_to_rename);
+
+ /* Now free the tzids_to_rename array. */
+ for (i = 0; i < tzids_to_rename->num_elements; i++) {
+ free (icalarray_element_at (tzids_to_rename, i));
+ }
+ icalarray_free (tzids_to_rename);
+ }
+
+ /* Now move all the components from comp_to_merge to comp, excluding
+ VTIMEZONE components. */
+ subcomp = icalcomponent_get_first_component (comp_to_merge,
+ ICAL_ANY_COMPONENT);
+ while (subcomp) {
+ next_subcomp = icalcomponent_get_next_component (comp_to_merge,
+ ICAL_ANY_COMPONENT);
+ if (icalcomponent_isa(subcomp) != ICAL_VTIMEZONE_COMPONENT) {
+ icalcomponent_remove_component (comp_to_merge, subcomp);
+ icalcomponent_add_component (comp, subcomp);
+ }
+ subcomp = next_subcomp;
+ }
+
+ /* Free comp_to_merge. We have moved most of the subcomponents over to
+ comp now. */
+ icalcomponent_free (comp_to_merge);
+}
+
+
+static void icalcomponent_merge_vtimezone (icalcomponent *comp,
+ icalcomponent *vtimezone,
+ icalarray *tzids_to_rename)
+{
+ icalproperty *tzid_prop;
+ const char *tzid;
+ icaltimezone *existing_vtimezone;
+
+ /* Get the TZID of the VTIMEZONE. */
+ tzid_prop = icalcomponent_get_first_property (comp, ICAL_TZID_PROPERTY);
+ if (!tzid_prop)
+ return;
+
+ tzid = icalproperty_get_tzid (tzid_prop);
+ if (!tzid)
+ return;
+
+ /* See if there is already a VTIMEZONE in comp with the same TZID. */
+ existing_vtimezone = icalcomponent_get_timezone (comp, tzid);
+
+ /* If there is no existing VTIMEZONE with the same TZID, we can just move
+ the VTIMEZONE to comp and return. */
+ if (!existing_vtimezone) {
+ icalcomponent_remove_component (icalcomponent_get_parent (vtimezone),
+ vtimezone);
+ icalcomponent_add_component (comp, vtimezone);
+ return;
+ }
+
+ /* If the TZID has a '/' prefix, then we don't have to worry about the
+ clashing TZIDs, as they are supposed to be exactly the same VTIMEZONE. */
+ if (tzid[0] == '/')
+ return;
+
+ /* Now we have two VTIMEZONEs with the same TZID (which isn't a globally
+ unique one), so we compare the VTIMEZONE components to see if they are
+ the same. If they are, we don't need to do anything. */
+ if (icalcomponent_compare_vtimezones (existing_vtimezone, vtimezone))
+ return;
+ /* FIXME: Handle possible NEWFAILED error. */
+
+ /* Now we have two different VTIMEZONEs with the same TZID. */
+ icalcomponent_handle_conflicting_vtimezones (comp, vtimezone, tzid_prop,
+ tzid, tzids_to_rename);
+}
+
+
+static void
+icalcomponent_handle_conflicting_vtimezones (icalcomponent *comp,
+ icalcomponent *vtimezone,
+ icalproperty *tzid_prop,
+ const char *tzid,
+ icalarray *tzids_to_rename)
+{
+ struct icalcomponent_impl *impl = (struct icalcomponent_impl*)comp;
+ int tzid_len, i, suffix, max_suffix = 0;
+ char *tzid_copy, *new_tzid, suffix_buf[32];
+
+ /* Find the length of the TZID without any trailing digits. */
+ tzid_len = icalcomponent_get_tzid_prefix_len (tzid);
+
+ /* Step through each of the VTIMEZONEs in comp. We may already have the
+ clashing VTIMEZONE in the calendar, but it may have been renamed
+ (i.e. a unique number added on the end of the TZID, e.g. 'London2').
+ So we compare the new VTIMEZONE with any VTIMEZONEs that have the
+ same prefix (e.g. 'London'). If it matches any of those, we have to
+ rename the TZIDs to that TZID, else we rename to a new TZID, using
+ the biggest numeric suffix found + 1. */
+ for (i = 0; i < impl->timezones->num_elements; i++) {
+ icaltimezone *zone;
+ char *existing_tzid, *existing_tzid_copy;
+ int existing_tzid_len;
+
+ zone = icalarray_element_at (impl->timezones, i);
+ existing_tzid = icaltimezone_get_tzid (zone);
+
+ /* Find the length of the TZID without any trailing digits. */
+ existing_tzid_len = icalcomponent_get_tzid_prefix_len (existing_tzid);
+
+ /* Check if we have the same prefix. */
+ if (tzid_len == existing_tzid_len
+ && !strncmp (tzid, existing_tzid, tzid_len)) {
+ /* Compare the VTIMEZONEs. */
+ if (icalcomponent_compare_vtimezones (icaltimezone_get_component (zone),
+ vtimezone)) {
+ /* The VTIMEZONEs match, so we can use the existing VTIMEZONE. But
+ we have to rename TZIDs to this TZID. */
+ tzid_copy = strdup (tzid);
+ existing_tzid_copy = strdup (existing_tzid);
+ if (!tzid_copy || !existing_tzid_copy) {
+ icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+ } else {
+ icalarray_append (tzids_to_rename, tzid_copy);
+ icalarray_append (tzids_to_rename, existing_tzid_copy);
+ }
+ return;
+ } else {
+ /* FIXME: Handle possible NEWFAILED error. */
+
+ /* Convert the suffix to an integer and remember the maximum numeric
+ suffix found. */
+ suffix = atoi (existing_tzid + existing_tzid_len);
+ if (max_suffix < suffix)
+ max_suffix = suffix;
}
-
- prop = icalcomponent_get_next_property (comp, ICAL_ANY_PROPERTY);
}
+ }
- /* Now recursively rename child components. */
- child = icalcomponent_get_first_component (comp, ICAL_ANY_COMPONENT);
- while (child) {
- icalcomponent_foreach_tzid (child, callback, callback_data);
- child = icalcomponent_get_next_component (comp, ICAL_ANY_COMPONENT);
- }
+ /* We didn't find a VTIMEZONE that matched, so we have to rename the TZID,
+ using the maximum numerical suffix found + 1. */
+ tzid_copy = strdup (tzid);
+ sprintf (suffix_buf, "%i", max_suffix + 1);
+ new_tzid = malloc (tzid_len + strlen (suffix_buf) + 1);
+ if (!new_tzid || !tzid_copy) {
+ icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+ return;
+ }
+
+ strncpy (new_tzid, tzid, tzid_len);
+ strcpy (new_tzid + tzid_len, suffix_buf);
+ icalarray_append (tzids_to_rename, tzid_copy);
+ icalarray_append (tzids_to_rename, new_tzid);
+}
+
+
+/* Returns the length of the TZID, without any trailing digits. */
+static int icalcomponent_get_tzid_prefix_len (const char *tzid)
+{
+ int len;
+ const char *p;
+
+ len = strlen (tzid);
+ p = tzid + len - 1;
+ while (len > 0 && *p >= '0' && *p <= '9') {
+ p--;
+ len--;
+ }
+
+ return len;
}
/* Renames all references to the given TZIDs to a new name. rename_table
contains pairs of strings - a current TZID, and the new TZID to rename it
to. */
-void icalcomponent_rename_tzids(icalcomponent* comp, icalarray* rename_table)
+static void icalcomponent_rename_tzids(icalcomponent* comp,
+ icalarray* rename_table)
{
icalcomponent_foreach_tzid (comp, icalcomponent_rename_tzids_callback,
rename_table);
@@ -1580,6 +1722,44 @@ static void icalcomponent_rename_tzids_callback(icalparameter *param, void *data
}
+/* Calls the given function for each TZID parameter found in the component. */
+void icalcomponent_foreach_tzid(icalcomponent* comp,
+ void (*callback)(icalparameter *param, void *data),
+ void *callback_data)
+{
+ icalproperty *prop;
+ icalproperty_kind kind;
+ icalparameter *param;
+ icalcomponent *subcomp;
+
+ /* First look for any TZID parameters used in this component itself. */
+ prop = icalcomponent_get_first_property (comp, ICAL_ANY_PROPERTY);
+ while (prop) {
+ kind = icalproperty_isa (prop);
+
+ /* These are the only properties that can have a TZID. Note that
+ COMPLETED, CREATED, DTSTAMP & LASTMODIFIED must be in UTC. */
+ if (kind == ICAL_DTSTART_PROPERTY || kind == ICAL_DTEND_PROPERTY
+ || kind == ICAL_DUE_PROPERTY || kind == ICAL_EXDATE_PROPERTY
+ || kind == ICAL_RDATE_PROPERTY) {
+ param = icalproperty_get_first_parameter (prop, ICAL_TZID_PARAMETER);
+ if (param)
+ (*callback) (param, callback_data);
+ }
+
+ prop = icalcomponent_get_next_property (comp, ICAL_ANY_PROPERTY);
+ }
+
+ /* Now recursively check child components. */
+ subcomp = icalcomponent_get_first_component (comp, ICAL_ANY_COMPONENT);
+ while (subcomp) {
+ icalcomponent_foreach_tzid (subcomp, callback, callback_data);
+ subcomp = icalcomponent_get_next_component (comp, ICAL_ANY_COMPONENT);
+ }
+}
+
+
+
/* Returns the icaltimezone from the component corresponding to the given
TZID, or NULL if the component does not have a corresponding VTIMEZONE. */
icaltimezone* icalcomponent_get_timezone(icalcomponent* comp, const char *tzid)
@@ -1609,3 +1789,67 @@ icaltimezone* icalcomponent_get_timezone(icalcomponent* comp, const char *tzid)
return NULL;
}
+
+/* Compares 2 VTIMEZONE components to see if they match, ignoring their TZIDs.
+ It returns 1 if they match, 0 if they don't, or -1 on error. */
+static int icalcomponent_compare_vtimezones (icalcomponent *vtimezone1,
+ icalcomponent *vtimezone2)
+{
+ icalproperty *prop1, *prop2;
+ const char *tzid1, *tzid2;
+ char *tzid2_copy, *string1, *string2;
+ int cmp;
+
+ /* Get the TZID property of the first VTIMEZONE. */
+ prop1 = icalcomponent_get_first_property (vtimezone1, ICAL_TZID_PROPERTY);
+ if (!prop1)
+ return -1;
+
+ tzid1 = icalproperty_get_tzid (prop1);
+ if (!tzid1)
+ return -1;
+
+ /* Get the TZID property of the second VTIMEZONE. */
+ prop2 = icalcomponent_get_first_property (vtimezone1, ICAL_TZID_PROPERTY);
+ if (!prop2)
+ return -1;
+
+ tzid2 = icalproperty_get_tzid (prop2);
+ if (!tzid2)
+ return -1;
+
+ /* Copy the second TZID, and set the property to the same as the first
+ TZID, since we don't care if these match of not. */
+ tzid2_copy = strdup (tzid2);
+ if (!tzid2_copy) {
+ icalerror_set_errno (ICAL_NEWFAILED_ERROR);
+ return 0;
+ }
+
+ icalproperty_set_tzid (prop2, tzid1);
+
+ /* Now convert both VTIMEZONEs to strings and compare them. */
+ string1 = icalcomponent_as_ical_string (vtimezone1);
+ if (!string1) {
+ free (tzid2_copy);
+ return -1;
+ }
+
+ string2 = icalcomponent_as_ical_string (vtimezone2);
+ if (!string2) {
+ free (string1);
+ free (tzid2_copy);
+ return -1;
+ }
+
+ cmp = strcmp (string1, string2);
+
+ free (string1);
+ free (string2);
+
+ /* Now reset the second TZID. */
+ icalproperty_set_tzid (prop2, tzid2_copy);
+ free (tzid2_copy);
+
+ return (cmp == 0) ? 1 : 0;
+}
diff --git a/libical/src/libical/icalcomponent.h b/libical/src/libical/icalcomponent.h
index 6046bbee1e..55c0592bb2 100644
--- a/libical/src/libical/icalcomponent.h
+++ b/libical/src/libical/icalcomponent.h
@@ -32,6 +32,14 @@
typedef void icalcomponent;
+/* An opaque struct representing a timezone. We declare this here to avoid
+ a circular dependancy. */
+#ifndef ICALTIMEONE_DEFINED
+#define ICALTIMEONE_DEFINED
+typedef struct _icaltimezone icaltimezone;
+#endif
+
+
/* This is exposed so that callers will not have to allocate and
deallocate iterators. Pretend that you can't see it. */
typedef struct icalcompiter
@@ -97,6 +105,13 @@ void icalcomponent_remove_component(icalcomponent* parent,
int icalcomponent_count_components(icalcomponent* component,
icalcomponent_kind kind);
+/* This takes 2 VCALENDAR components and merges the second one into the first,
+ resolving any problems with conflicting TZIDs. comp_to_merge will no
+ longer exist after calling this function. */
+void icalcomponent_merge_component(icalcomponent* comp,
+ icalcomponent* comp_to_merge);
+
+
/* Iteration Routines. There are two forms of iterators, internal and
external. The internal ones came first, and are almost completely
sufficient, but they fail badly when you want to construct a loop that
@@ -217,7 +232,16 @@ int icalcomponent_remove_attendee(icalcomponent *comp, char* cuid);
struct icalattendeetype icalcomponent_get_attendee(icalcomponent *comp,
int index);
+/* Calls the given function for each TZID parameter found in the component,
+ and any subcomponents. */
+void icalcomponent_foreach_tzid(icalcomponent* comp,
+ void (*callback)(icalparameter *param, void *data),
+ void *callback_data);
+/* Returns the icaltimezone in the component corresponding to the TZID, or NULL
+ if it can't be found. */
+icaltimezone* icalcomponent_get_timezone(icalcomponent* comp,
+ const char *tzid);
/*************** Type Specific routines ***************/
diff --git a/libical/src/libical/icaltime.c b/libical/src/libical/icaltime.c
index 6a3859c094..6f6ed5748f 100644
--- a/libical/src/libical/icaltime.c
+++ b/libical/src/libical/icaltime.c
@@ -44,6 +44,7 @@
#include "icalmemory.h"
#endif
+#include "icaltimezone.h"
@@ -73,6 +74,41 @@ icaltime_from_timet(time_t tm, int is_date)
return tt;
}
+struct icaltimetype
+icaltime_from_timet_with_zone(time_t tm, int is_date, icaltimezone *zone)
+{
+ struct icaltimetype tt = icaltime_null_time();
+ struct tm t;
+ icaltimezone *utc_zone;
+
+ utc_zone = icaltimezone_get_utc_timezone ();
+
+ /* Convert the time_t to a struct tm in UTC time. We can trust gmtime
+ for this. */
+ t = *(gmtime(&tm));
+
+ tt.year = t.tm_year + 1900;
+ tt.month = t.tm_mon + 1;
+ tt.day = t.tm_mday;
+ tt.hour = t.tm_hour;
+ tt.minute = t.tm_min;
+ tt.second = t.tm_sec;
+
+ tt.is_utc = (zone == utc_zone) ? 1 : 0;
+ tt.is_date = is_date;
+ tt.is_daylight = 0;
+
+ /* Use our timezone functions to convert to the required timezone. */
+ icaltimezone_convert_time (&tt, utc_zone, zone);
+
+ if (is_date) {
+ /* FIXME: is_daylight may need to be changed. */
+ tt.second = tt.minute = tt.hour = 0;
+ }
+
+ return tt;
+}
+
/* Structure used by set_tz to hold an old value of TZ, and the new
value, which is in memory we will have to free in unset_tz */
/* This will hold the last "TZ=XXX" string we used with putenv(). After we
@@ -177,6 +213,42 @@ time_t icaltime_as_timet(struct icaltimetype tt)
}
+time_t icaltime_as_timet_with_zone(struct icaltimetype tt, icaltimezone *zone)
+{
+ icaltimezone *utc_zone;
+ struct tm stm;
+ time_t t;
+ char *old_tz;
+
+ utc_zone = icaltimezone_get_utc_timezone ();
+
+ /* If the time is the special null time, return 0. */
+ if (icaltime_is_null_time(tt)) {
+ return 0;
+ }
+
+ /* Use our timezone functions to convert to UTC. */
+ icaltimezone_convert_time (&tt, zone, utc_zone);
+
+ /* Copy the icaltimetype to a struct tm. */
+ memset (&stm, 0, sizeof (struct tm));
+
+ stm.tm_sec = tt.second;
+ stm.tm_min = tt.minute;
+ stm.tm_hour = tt.hour;
+ stm.tm_mday = tt.day;
+ stm.tm_mon = tt.month-1;
+ stm.tm_year = tt.year-1900;
+ stm.tm_isdst = -1;
+
+ /* Set TZ to UTC and use mktime to convert to a time_t. */
+ old_tz = set_tz ("UTC");
+ t = mktime (&stm);
+ unset_tz (old_tz);
+
+ return t;
+}
+
char* icaltime_as_ical_string(struct icaltimetype tt)
{
size_t size = 17;
@@ -202,101 +274,12 @@ char* icaltime_as_ical_string(struct icaltimetype tt)
}
-/* convert tt, of timezone tzid, into a utc time */
-struct icaltimetype icaltime_as_utc(struct icaltimetype tt,const char* tzid)
-{
- int tzid_offset;
-
- if(tt.is_utc == 1 || tt.is_date == 1){
- return tt;
- }
-
- tzid_offset = icaltime_utc_offset(tt,tzid);
-
- tt.second -= tzid_offset;
-
- tt.is_utc = 1;
-
- return icaltime_normalize(tt);
-}
-
-/* convert tt, a time in UTC, into a time in timezone tzid */
-struct icaltimetype icaltime_as_zone(struct icaltimetype tt,const char* tzid)
-{
- int tzid_offset;
-
- tzid_offset = icaltime_utc_offset(tt,tzid);
-
- tt.second += tzid_offset;
-
- tt.is_utc = 0;
-
- return icaltime_normalize(tt);
-
-}
-
-
-/* Return the offset of the named zone as seconds. tt is a time
- indicating the date for which you want the offset */
-int icaltime_utc_offset(struct icaltimetype ictt, const char* tzid)
-{
-
- time_t tt = icaltime_as_timet(ictt);
- time_t offset_tt;
- struct tm gtm;
-
- char *tz_str = 0;
-
- if(tzid != 0){
- tz_str = set_tz(tzid);
- }
-
- /* Mis-interpret a UTC broken out time as local time */
- gtm = *(gmtime(&tt));
- gtm.tm_isdst = localtime(&tt)->tm_isdst;
- offset_tt = mktime(&gtm);
-
- if(tzid != 0){
- unset_tz(tz_str);
- }
-
- return tt-offset_tt;
-}
-
-
-
-/* Normalize by converting from localtime to utc and back to local
- time. This uses localtime because localtime and mktime are inverses
- of each other */
+/* Normalize the icaltime, so that all fields are within the normal range. */
struct icaltimetype icaltime_normalize(struct icaltimetype tt)
{
- struct tm stm;
- time_t tut;
-
- memset(&stm,0,sizeof( struct tm));
-
- stm.tm_sec = tt.second;
- stm.tm_min = tt.minute;
- stm.tm_hour = tt.hour;
- stm.tm_mday = tt.day;
- stm.tm_mon = tt.month-1;
- stm.tm_year = tt.year-1900;
- stm.tm_isdst = -1; /* prevents mktime from changing hour based on
- daylight savings */
-
- tut = mktime(&stm);
-
- stm = *(localtime(&tut));
-
- tt.second = stm.tm_sec;
- tt.minute = stm.tm_min;
- tt.hour = stm.tm_hour;
- tt.day = stm.tm_mday;
- tt.month = stm.tm_mon +1;
- tt.year = stm.tm_year+1900;
-
- return tt;
+ icaltime_adjust (&tt, 0, 0, 0, 0);
+ return tt;
}
@@ -404,50 +387,69 @@ short icaltime_day_of_week(struct icaltimetype t){
return stm.tm_wday + 1;
}
-/* Day of the year that the first day of the week (Sunday) is on */
+/* Day of the year that the first day of the week (Sunday) is on.
+ FIXME: Doesn't take into account different week start days. */
short icaltime_start_doy_of_week(struct icaltimetype t){
- time_t tt = icaltime_as_timet(t);
- time_t start_tt;
- struct tm *stm;
- int syear;
+ struct tm stm;
- stm = gmtime(&tt);
- syear = stm->tm_year;
+ stm.tm_year = t.year - 1900;
+ stm.tm_mon = t.month - 1;
+ stm.tm_mday = t.day;
+ stm.tm_hour = 0;
+ stm.tm_min = 0;
+ stm.tm_sec = 0;
+ stm.tm_isdst = -1;
- start_tt = tt - stm->tm_wday*(60*60*24);
+ mktime (&stm);
- stm = gmtime(&start_tt);
-
- if(syear == stm->tm_year){
- return stm->tm_yday+1;
+ /* Move back to the start of the week. */
+ stm.tm_mday -= stm.tm_wday;
+
+ mktime (&stm);
+
+ /* If we are still in the same year as the original date, we just return
+ the day of the year. */
+ if (t.year - 1900 == stm.tm_year){
+ return stm.tm_yday+1;
} else {
/* return negative to indicate that start of week is in
previous year. */
int is_leap = 0;
- int year = stm->tm_year;
+ int year = stm.tm_year;
if( (year % 4 == 0 && year % 100 != 0) ||
year % 400 == 0){
is_leap =1;
}
- return (stm->tm_yday+1)-(365+is_leap);
+ return (stm.tm_yday+1)-(365+is_leap);
}
}
+/* FIXME: Doesn't take into account the start day of the week. strftime assumes
+ that weeks start on Monday. */
short icaltime_week_number(struct icaltimetype ictt)
{
- char str[5];
- time_t t = icaltime_as_timet(ictt);
+ struct tm stm;
int week_no;
+ char str[8];
- strftime(str,5,"%V", gmtime(&t));
+ stm.tm_year = ictt.year - 1900;
+ stm.tm_mon = ictt.month - 1;
+ stm.tm_mday = ictt.day;
+ stm.tm_hour = 0;
+ stm.tm_min = 0;
+ stm.tm_sec = 0;
+ stm.tm_isdst = -1;
+
+ mktime (&stm);
+
+ strftime(str,5,"%V", &stm);
week_no = atoi(str);
return week_no;
-
}
diff --git a/libical/src/libical/icaltime.h b/libical/src/libical/icaltime.h
index afe8fd4df2..ef3d65d030 100644
--- a/libical/src/libical/icaltime.h
+++ b/libical/src/libical/icaltime.h
@@ -31,6 +31,13 @@
#include <time.h>
+/* An opaque struct representing a timezone. We declare this here to avoid
+ a circular dependancy. */
+#ifndef ICALTIMEONE_DEFINED
+#define ICALTIMEONE_DEFINED
+typedef struct _icaltimezone icaltimezone;
+#endif
+
/* icaltime_span is returned by icalcomponent_get_span() */
struct icaltime_span {
time_t start; /* in UTC */
@@ -60,9 +67,16 @@ struct icaltimetype
/* Convert seconds past UNIX epoch to a timetype*/
struct icaltimetype icaltime_from_timet(time_t v, int is_date);
+/* Newer version of above, using timezones. */
+struct icaltimetype icaltime_from_timet_with_zone(time_t tm, int is_date,
+ icaltimezone *zone);
+
/* Return the time as seconds past the UNIX epoch */
time_t icaltime_as_timet(struct icaltimetype);
+/* Newer version of above, using timezones. */
+time_t icaltime_as_timet_with_zone(struct icaltimetype tt, icaltimezone *zone);
+
/* Return a string represention of the time, in RFC2445 format. The
string is owned by libical */
char* icaltime_as_ical_string(struct icaltimetype tt);
@@ -77,20 +91,6 @@ int icaltime_as_int(struct icaltimetype);
/* create a time from an ISO format string */
struct icaltimetype icaltime_from_string(const char* str);
-/* Routines for handling timezones */
-/* Return the offset of the named zone as seconds. tt is a time
- indicating the date for which you want the offset */
-int icaltime_utc_offset(struct icaltimetype tt, const char* tzid);
-
-/* convert tt, of timezone tzid, into a utc time. Does nothing if the
- time is already UTC. */
-struct icaltimetype icaltime_as_utc(struct icaltimetype tt,
- const char* tzid);
-
-/* convert tt, a time in UTC, into a time in timezone tzid */
-struct icaltimetype icaltime_as_zone(struct icaltimetype tt,
- const char* tzid);
-
/* Return a null time, which indicates no time has been set. This time represent the beginning of the epoch */
struct icaltimetype icaltime_null_time(void);
diff --git a/libical/src/libical/icaltimezone.c b/libical/src/libical/icaltimezone.c
index 796e01a3ea..def5c1a6fc 100644
--- a/libical/src/libical/icaltimezone.c
+++ b/libical/src/libical/icaltimezone.c
@@ -30,15 +30,19 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include "icalproperty.h"
#include "icalarray.h"
#include "icalerror.h"
#include "icalparser.h"
#include "icaltimezone.h"
-
/* This is the toplevel directory where the timezone data is installed in. */
#define ZONEINFO_DIRECTORY PACKAGE_DATA_DIR "/zoneinfo"
+/* The prefix we use to uniquely identify TZIDs. */
+#define TZID_PREFIX "/softwarestudio.org/"
+#define TZID_PREFIX_LEN 20
+
/* This is the filename of the file containing the city names and coordinates
of all the builtin timezones. */
#define ZONES_TAB_FILENAME "zones.tab"
@@ -49,7 +53,7 @@
/* This is the maximum year we will expand to. time_t values only go up to
somewhere around 2037. */
-#define ICALTIMEZONE_MAX_YEAR 2032
+#define ICALTIMEZONE_MAX_YEAR 2035
struct _icaltimezone {
@@ -130,6 +134,9 @@ icaltimezone utc_timezone = { 0 };
+static void icaltimezone_reset (icaltimezone *zone);
+static char* icaltimezone_get_location_from_vtimezone (icalcomponent *component);
+static char* icaltimezone_get_tznames_from_vtimezone (icalcomponent *component);
static void icaltimezone_expand_changes (icaltimezone *zone,
int end_year);
static void icaltimezone_expand_vtimezone (icalcomponent *comp,
@@ -149,14 +156,14 @@ static void icaltimezone_adjust_change (icaltimezonechange *tt,
static void icaltimezone_init (icaltimezone *zone);
-/* Initializes an icaltimezone from the given VTIMEZONE component. It gets
- the TZID from the VTIMEZONE component. It returns 1 on success, or 0 if
- the TZID can't be found. */
-static int icaltimezone_init_from_vtimezone (icaltimezone *zone,
- icalcomponent *component);
+/* Gets the TZID, LOCATION/X-LIC-LOCATION, and TZNAME properties from the
+ VTIMEZONE component and places them in the icaltimezone. It returns 1 on
+ success, or 0 if the TZID can't be found. */
+static int icaltimezone_get_vtimezone_properties (icaltimezone *zone,
+ icalcomponent *component);
-static void icaltimezone_load (icaltimezone *zone);
+static void icaltimezone_load_builtin_timezone (icaltimezone *zone);
static void icaltimezone_ensure_coverage (icaltimezone *zone,
int end_year);
@@ -174,8 +181,53 @@ static void format_utc_offset (int utc_offset,
char *buffer);
+/* Creates a new icaltimezone. */
+icaltimezone*
+icaltimezone_new (void)
+{
+ icaltimezone *zone;
+
+ zone = (icaltimezone*) malloc (sizeof (icaltimezone));
+ if (!zone) {
+ icalerror_set_errno (ICAL_NEWFAILED_ERROR);
+ return;
+ }
+
+ icaltimezone_init (zone);
-/* Initializes an icaltimezone with the given TZID. */
+ return zone;
+}
+
+
+/* Frees all memory used for the icaltimezone. */
+void
+icaltimezone_free (icaltimezone *zone)
+{
+ icaltimezone_reset (zone);
+ free (zone);
+}
+
+
+/* Resets the icaltimezone to the initial state, freeing most of the fields. */
+static void
+icaltimezone_reset (icaltimezone *zone)
+{
+ if (zone->tzid)
+ free (zone->tzid);
+ if (zone->location)
+ free (zone->location);
+ if (zone->tznames)
+ free (zone->tznames);
+ if (zone->component)
+ icalcomponent_free (zone->component);
+ if (zone->changes)
+ icalarray_free (zone->changes);
+
+ icaltimezone_init (zone);
+}
+
+
+/* Initializes an icaltimezone. */
static void
icaltimezone_init (icaltimezone *zone)
{
@@ -191,31 +243,171 @@ icaltimezone_init (icaltimezone *zone)
}
-/* Initializes an icaltimezone from the given VTIMEZONE component. It gets
- the TZID from the VTIMEZONE component. It returns 1 on success, or 0 if
- the TZID can't be found. */
+/* Gets the TZID, LOCATION/X-LIC-LOCATION and TZNAME properties of the
+ VTIMEZONE component and stores them in the icaltimezone.
+ It returns 1 on success, or 0 if the TZID can't be found.
+ Note that it expects the zone to be initialized or reset - it doesn't free
+ any old values. */
static int
-icaltimezone_init_from_vtimezone (icaltimezone *zone,
+icaltimezone_get_vtimezone_properties (icaltimezone *zone,
icalcomponent *component)
{
icalproperty *prop;
- const char *tzid;
-
+ const char *tzid, *location;
+
prop = icalcomponent_get_first_property (component, ICAL_TZID_PROPERTY);
if (!prop)
return 0;
+ /* A VTIMEZONE MUST have a TZID, or a lot of our code won't work. */
tzid = icalproperty_get_tzid (prop);
if (!tzid)
return 0;
- icaltimezone_init (zone);
zone->tzid = strdup (tzid);
zone->component = component;
+ zone->location = icaltimezone_get_location_from_vtimezone (component);
+ zone->tznames = icaltimezone_get_tznames_from_vtimezone (component);
return 1;
}
+/* Gets the LOCATION or X-LIC-LOCATION property from a VTIMEZONE. */
+static char*
+icaltimezone_get_location_from_vtimezone (icalcomponent *component)
+{
+ icalproperty *prop;
+ const char *location;
+ char *name;
+ int found_location = 0;
+
+ prop = icalcomponent_get_first_property (component,
+ ICAL_LOCATION_PROPERTY);
+ if (prop) {
+ location = icalproperty_get_location (prop);
+ if (location)
+ return strdup (location);
+ }
+
+ prop = icalcomponent_get_first_property (component, ICAL_X_PROPERTY);
+ while (prop) {
+ name = icalproperty_get_x_name (prop);
+ if (name && !strcmp (name, "X-LIC-LOCATION")) {
+ location = icalproperty_get_x (prop);
+ if (location)
+ return strdup (location);
+ }
+ prop = icalcomponent_get_next_property (component,
+ ICAL_X_PROPERTY);
+ }
+}
+
+
+/* Gets the TZNAMEs used for the last STANDARD & DAYLIGHT components in a
+ VTIMEZONE. If both STANDARD and DAYLIGHT components use the same TZNAME,
+ it returns that. If they use different TZNAMEs, it formats them like
+ "EST/EDT". The returned string should be freed by the caller. */
+static char*
+icaltimezone_get_tznames_from_vtimezone (icalcomponent *component)
+{
+ icalcomponent *comp;
+ icalcomponent_kind type;
+ icalproperty *prop;
+ struct icaltimetype dtstart;
+ struct icaldatetimeperiodtype rdate;
+ const char *current_tzname;
+ const char *standard_tzname = NULL, *daylight_tzname = NULL;
+ struct icaltimetype standard_max_date, daylight_max_date;
+ struct icaltimetype current_max_date;
+
+ /* Step through the STANDARD & DAYLIGHT subcomponents. */
+ comp = icalcomponent_get_first_component (component, ICAL_ANY_COMPONENT);
+ while (comp) {
+ type = icalcomponent_isa (comp);
+ if (type == ICAL_XSTANDARD_COMPONENT
+ || type == ICAL_XDAYLIGHT_COMPONENT) {
+ current_max_date = icaltime_null_time ();
+ current_tzname = NULL;
+
+ /* Step through the properties. We want to find the TZNAME, and
+ the largest DTSTART or RDATE. */
+ prop = icalcomponent_get_first_property (comp, ICAL_ANY_PROPERTY);
+ while (prop) {
+ switch (icalproperty_isa (prop)) {
+ case ICAL_TZNAME_PROPERTY:
+ current_tzname = icalproperty_get_tzname (prop);
+ break;
+
+ case ICAL_DTSTART_PROPERTY:
+ dtstart = icalproperty_get_dtstart (prop);
+ if (icaltime_compare (dtstart, current_max_date) > 0)
+ current_max_date = dtstart;
+
+ break;
+
+ case ICAL_RDATE_PROPERTY:
+ rdate = icalproperty_get_rdate (prop);
+ if (icaltime_compare (rdate.time, current_max_date) > 0)
+ current_max_date = rdate.time;
+
+ break;
+
+ default:
+ break;
+ }
+
+ prop = icalcomponent_get_next_property (comp,
+ ICAL_ANY_PROPERTY);
+ }
+
+ if (current_tzname) {
+ if (type == ICAL_XSTANDARD_COMPONENT) {
+ if (!standard_tzname
+ || icaltime_compare (current_max_date,
+ standard_max_date) > 0) {
+ standard_max_date = current_max_date;
+ standard_tzname = current_tzname;
+ }
+ } else {
+ if (!daylight_tzname
+ || icaltime_compare (current_max_date,
+ daylight_max_date) > 0) {
+ daylight_max_date = current_max_date;
+ daylight_tzname = current_tzname;
+ }
+ }
+ }
+ }
+
+ comp = icalcomponent_get_next_component (component,
+ ICAL_ANY_COMPONENT);
+ }
+
+ /* If both standard and daylight TZNAMEs were found, if they are the same
+ we return just one, else we format them like "EST/EDT". */
+ if (standard_tzname && daylight_tzname) {
+ int standard_len, daylight_len;
+ char *tznames;
+
+ if (!strcmp (standard_tzname, daylight_tzname))
+ return strdup (standard_tzname);
+
+ standard_len = strlen (standard_tzname);
+ daylight_len = strlen (daylight_tzname);
+ tznames = malloc (standard_len + daylight_len + 2);
+ strcpy (tznames, standard_tzname);
+ tznames[standard_len] = '/';
+ strcpy (tznames + standard_len + 1, daylight_tzname);
+ return tznames;
+ } else {
+ const char *tznames;
+
+ /* If either of the TZNAMEs was found just return that, else NULL. */
+ tznames = standard_tzname ? standard_tzname : daylight_tzname;
+ return strdup (tznames);
+ }
+}
+
static void
icaltimezone_ensure_coverage (icaltimezone *zone,
@@ -228,7 +420,7 @@ icaltimezone_ensure_coverage (icaltimezone *zone,
int changes_end_year;
if (!zone->component)
- icaltimezone_load (zone);
+ icaltimezone_load_builtin_timezone (zone);
if (icaltimezone_minimum_expansion_year == -1) {
struct tm *tmp_tm;
@@ -922,80 +1114,37 @@ icaltimezone_adjust_change (icaltimezonechange *tt,
}
-
-/* Compares 2 VTIMEZONE components to see if they match, ignoring their TZIDs.
- It returns 1 if they match, 0 if they don't, or -1 on error. */
-int
-icaltimezone_compare_vtimezone (icalcomponent *vtimezone1,
- icalcomponent *vtimezone2)
+char*
+icaltimezone_get_tzid (icaltimezone *zone)
{
- icalproperty *prop1, *prop2;
- const char *tzid1, *tzid2;
- char *tzid2_copy, *string1, *string2;
- int cmp;
-
- /* Get the TZID property of the first VTIMEZONE. */
- prop1 = icalcomponent_get_first_property (vtimezone1, ICAL_TZID_PROPERTY);
- if (!prop1)
- return -1;
-
- tzid1 = icalproperty_get_tzid (prop1);
- if (!tzid1)
- return -1;
-
- /* Get the TZID property of the second VTIMEZONE. */
- prop2 = icalcomponent_get_first_property (vtimezone1, ICAL_TZID_PROPERTY);
- if (!prop2)
- return -1;
-
- tzid2 = icalproperty_get_tzid (prop2);
- if (!tzid2)
- return -1;
-
- /* Copy the second TZID, and set the property to the same as the first
- TZID, since we don't care if these match of not. */
- tzid2_copy = strdup (tzid2);
- icalproperty_set_tzid (prop2, tzid1);
-
- /* Now convert both VTIMEZONEs to strings and compare them. */
- string1 = icalcomponent_as_ical_string (vtimezone1);
- if (!string1) {
- free (tzid2_copy);
- return -1;
- }
-
- string2 = icalcomponent_as_ical_string (vtimezone2);
- if (!string2) {
- free (string1);
- free (tzid2_copy);
- return -1;
- }
+ /* If this is a local time, without a timezone, return NULL. */
+ if (!zone)
+ return NULL;
- cmp = strcmp (string1, string2);
-
- free (string1);
- free (string2);
-
- /* Now reset the second TZID. */
- icalproperty_set_tzid (prop2, tzid2_copy);
- free (tzid2_copy);
+ if (!zone->component)
+ icaltimezone_load_builtin_timezone (zone);
- return (cmp == 0) ? 1 : 0;
+ return zone->tzid;
}
-
char*
-icaltimezone_get_tzid (icaltimezone *zone)
+icaltimezone_get_location (icaltimezone *zone)
{
- return zone->tzid;
+ if (!zone->component)
+ icaltimezone_load_builtin_timezone (zone);
+
+ return zone->location;
}
char*
-icaltimezone_get_location (icaltimezone *zone)
+icaltimezone_get_tznames (icaltimezone *zone)
{
- return zone->location;
+ if (!zone->component)
+ icaltimezone_load_builtin_timezone (zone);
+
+ return zone->tznames;
}
@@ -1003,6 +1152,9 @@ icaltimezone_get_location (icaltimezone *zone)
double
icaltimezone_get_latitude (icaltimezone *zone)
{
+ if (!zone->component)
+ icaltimezone_load_builtin_timezone (zone);
+
return zone->latitude;
}
@@ -1011,6 +1163,9 @@ icaltimezone_get_latitude (icaltimezone *zone)
double
icaltimezone_get_longitude (icaltimezone *zone)
{
+ if (!zone->component)
+ icaltimezone_load_builtin_timezone (zone);
+
return zone->longitude;
}
@@ -1019,8 +1174,22 @@ icaltimezone_get_longitude (icaltimezone *zone)
icalcomponent*
icaltimezone_get_component (icaltimezone *zone)
{
+ if (!zone->component)
+ icaltimezone_load_builtin_timezone (zone);
+
return zone->component;
+}
+
+/* Sets the VTIMEZONE component of an icaltimezone, initializing the tzid,
+ location & tzname fields. It returns 1 on success or 0 on failure, i.e.
+ no TZID was found. */
+int
+icaltimezone_set_component (icaltimezone *zone,
+ icalcomponent *comp)
+{
+ icaltimezone_reset (zone);
+ return icaltimezone_get_vtimezone_properties (zone, comp);
}
@@ -1037,7 +1206,8 @@ icaltimezone_array_append_from_vtimezone (icalarray *timezones,
{
icaltimezone zone;
- if (icaltimezone_init_from_vtimezone (&zone, child))
+ icaltimezone_init (&zone);
+ if (icaltimezone_get_vtimezone_properties (&zone, child))
icalarray_append (timezones, &zone);
}
@@ -1061,7 +1231,95 @@ icaltimezone_get_builtin_timezones (void)
}
-/* Returns an icaltimezone corresponding to the given location. */
+/* Returns a single builtin timezone, given its Olson city name. */
+icaltimezone*
+icaltimezone_get_builtin_timezone (const char *location)
+{
+ icaltimezone *zone;
+ int lower, upper, middle, cmp;
+ char *zone_location;
+
+ fprintf (stderr, "Getting builtin timezone: %s\n", location);
+
+ if (!location || !location[0])
+ return NULL;
+
+ if (!strcmp (location, "UTC"))
+ return &utc_timezone;
+
+ if (!builtin_timezones)
+ icaltimezone_init_builtin_timezones ();
+
+ /* Do a simple binary search. */
+ lower = middle = 0;
+ upper = builtin_timezones->num_elements;
+
+ while (lower < upper) {
+ middle = (lower + upper) >> 1;
+ zone = icalarray_element_at (builtin_timezones, middle);
+ zone_location = icaltimezone_get_location (zone);
+ fprintf (stderr, " comparing with: %s\n", zone_location);
+ cmp = strcmp (location, zone_location);
+ if (cmp == 0)
+ return zone;
+ else if (cmp < 0)
+ upper = middle;
+ else
+ lower = middle + 1;
+ }
+
+ fprintf (stderr, " not found\n");
+
+ return NULL;
+}
+
+
+/* Returns a single builtin timezone, given its TZID. */
+icaltimezone*
+icaltimezone_get_builtin_timezone_from_tzid (const char *tzid)
+{
+ int num_slashes = 0;
+ const char *p, *zone_tzid;
+ icaltimezone *zone;
+
+ fprintf (stderr, "Getting builtin timezone from TZID: %s\n", tzid);
+
+ /* Check that the TZID starts with our unique prefix. */
+ if (strncmp (tzid, TZID_PREFIX, TZID_PREFIX_LEN))
+ return NULL;
+
+ /* Get the location, which is after the 3rd '/' character. */
+ p = tzid;
+ for (p = tzid; *p; p++) {
+ if (*p == '/') {
+ num_slashes++;
+ if (num_slashes == 3)
+ break;
+ }
+ }
+
+ if (num_slashes != 3)
+ return NULL;
+
+ p++;
+
+ /* Now we can use the function to get the builtin timezone from the
+ location string. */
+ zone = icaltimezone_get_builtin_timezone (p);
+ if (!zone)
+ return NULL;
+
+ /* Check that the builtin TZID matches exactly. We don't want to return
+ a different version of the VTIMEZONE. */
+ zone_tzid = icaltimezone_get_tzid (zone);
+ if (!strcmp (zone_tzid, tzid))
+ return zone;
+ else
+ return NULL;
+}
+
+
+/* Returns the special UTC timezone. */
icaltimezone*
icaltimezone_get_utc_timezone (void)
{
@@ -1104,6 +1362,8 @@ icaltimezone_parse_zone_tab (void)
icalerror_assert (builtin_timezones == NULL,
"Parsing zones.tab file multiple times");
+ builtin_timezones = icalarray_new (sizeof (icaltimezone), 32);
+
filename_len = strlen (ZONEINFO_DIRECTORY) + strlen (ZONES_TAB_FILENAME)
+ 2;
@@ -1123,8 +1383,6 @@ icaltimezone_parse_zone_tab (void)
return;
}
- builtin_timezones = icalarray_new (sizeof (icaltimezone), 32);
-
while (fgets (buf, sizeof(buf), fp)) {
if (*buf == '#') continue;
@@ -1174,13 +1432,17 @@ icaltimezone_parse_zone_tab (void)
/* Loads the builtin VTIMEZONE data for the given timezone. */
static void
-icaltimezone_load (icaltimezone *zone)
+icaltimezone_load_builtin_timezone (icaltimezone *zone)
{
char *filename;
int filename_len;
FILE *fp;
icalparser *parser;
- icalcomponent *comp;
+ icalcomponent *comp, *subcomp;
+
+ /* If the location isn't set, it isn't a builtin timezone. */
+ if (!zone->location || !zone->location[0])
+ return;
filename_len = strlen (ZONEINFO_DIRECTORY) + strlen (zone->location) + 6;
@@ -1207,7 +1469,14 @@ icaltimezone_load (icaltimezone *zone)
fclose (fp);
/* Find the VTIMEZONE component inside the VCALENDAR. There should be 1. */
- zone->component = icalcomponent_get_first_component (comp, ICAL_VTIMEZONE_COMPONENT);
+ subcomp = icalcomponent_get_first_component (comp,
+ ICAL_VTIMEZONE_COMPONENT);
+ if (!subcomp) {
+ icalerror_set_errno(ICAL_PARSE_ERROR);
+ return;
+ }
+
+ icaltimezone_get_vtimezone_properties (zone, subcomp);
}
diff --git a/libical/src/libical/icaltimezone.h b/libical/src/libical/icaltimezone.h
index 2f6487e1e9..693d6bbb80 100644
--- a/libical/src/libical/icaltimezone.h
+++ b/libical/src/libical/icaltimezone.h
@@ -29,11 +29,19 @@
#include <stdio.h> /* For FILE* */
#include "icaltime.h"
+#include "icalarray.h"
+#include "icalcomponent.h"
-/* An opaque struct representing a timezone. */
-typedef struct _icaltimezone icaltimezone;
+/*
+ * Creating/Destroying individual icaltimezones.
+ */
+/* Creates a new icaltimezone. */
+icaltimezone *icaltimezone_new (void);
+
+/* Frees all memory used for the icaltimezone. */
+void icaltimezone_free (icaltimezone *zone);
/*
@@ -46,6 +54,9 @@ icalarray* icaltimezone_get_builtin_timezones (void);
/* Returns a single builtin timezone, given its Olson city name. */
icaltimezone* icaltimezone_get_builtin_timezone (const char *location);
+/* Returns a single builtin timezone, given its TZID. */
+icaltimezone* icaltimezone_get_builtin_timezone_from_tzid (const char *tzid);
+
/* Returns the UTC timezone. */
icaltimezone* icaltimezone_get_utc_timezone (void);
@@ -55,6 +66,12 @@ char* icaltimezone_get_tzid (icaltimezone *zone);
/* Returns the city name of a timezone. */
char* icaltimezone_get_location (icaltimezone *zone);
+/* Returns the TZNAME properties used in the latest STANDARD and DAYLIGHT
+ components. If they are the same it will return just one, e.g. "LMT".
+ If they are different it will format them like "EST/EDT". Note that this
+ may also return NULL. */
+char* icaltimezone_get_tznames (icaltimezone *zone);
+
/* Returns the latitude of a builtin timezone. */
double icaltimezone_get_latitude (icaltimezone *zone);
@@ -64,6 +81,11 @@ double icaltimezone_get_longitude (icaltimezone *zone);
/* Returns the VTIMEZONE component of a timezone. */
icalcomponent* icaltimezone_get_component (icaltimezone *zone);
+/* Sets the VTIMEZONE component of an icaltimezone, initializing the tzid,
+ location & tzname fields. It returns 1 on success or 0 on failure, i.e.
+ no TZID was found. */
+int icaltimezone_set_component (icaltimezone *zone,
+ icalcomponent *comp);
/*
* Converting times between timezones.
@@ -94,21 +116,8 @@ int icaltimezone_get_utc_offset_of_utc_time (icaltimezone *zone,
-
-/*
- * Comparing VTIMEZONE components.
- */
-
-/* Compares 2 VTIMEZONE components to see if they match, ignoring their TZIDs.
- It returns 1 if they match, 0 if they don't, or -1 on error. */
-int icaltimezone_compare_vtimezone (icalcomponent *vtimezone1,
- icalcomponent *vtimezone2);
-
-
-
-
/*
- * Handling arrays of timezones.
+ * Handling arrays of timezones. Mainly for internal use.
*/
icalarray* icaltimezone_array_new (void);