X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Fical_dezonify.c;h=04d41e7c90b0887cd5c2b02dac946bd8028d4c4c;hb=6fa6542eb4a8f390488f2a453baec1bf8de1a1fb;hp=d1eb6952115978725d3d1e035ec95bc3069f0efd;hpb=b97032edde0fc71325784d4dc79412b6bd7ad652;p=citadel.git diff --git a/citadel/ical_dezonify.c b/citadel/ical_dezonify.c index d1eb69521..04d41e7c9 100644 --- a/citadel/ical_dezonify.c +++ b/citadel/ical_dezonify.c @@ -1,57 +1,118 @@ -/* - * $Id$ - * +/* * Function to go through an ical component set and convert all non-UTC - * DTSTART and DTEND properties to UTC. It also strips out any VTIMEZONE + * date/time properties to UTC. It also strips out any VTIMEZONE * subcomponents afterwards, because they're irrelevant. * + * Copyright (c) 1987-2017 by the citadel.org team + * + * This program is open source software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. */ -#ifdef HAVE_ICAL_H +#include "sysdep.h" #include #include -#include -#include -#include #include -#include +#include +#include +#include +#include +#include +#include +#include +#include "citadel.h" +#include "server.h" +#include "citserver.h" +#include "sysdep_decls.h" +#include "support.h" +#include "config.h" #include "ical_dezonify.h" +#include "ctdl_module.h" + + +/* + * Figure out which time zone needs to be used for timestamps that are + * not UTC and do not have a time zone specified. + */ +icaltimezone *get_default_icaltimezone(void) { + + icaltimezone *zone = NULL; + char *default_zone_name = CtdlGetConfigStr("c_default_cal_zone"); + + if (!zone) { + zone = icaltimezone_get_builtin_timezone(default_zone_name); + } + if (!zone) { + syslog(LOG_ERR, "ical: Unable to load '%s' time zone. Defaulting to UTC.", default_zone_name); + zone = icaltimezone_get_utc_timezone(); + } + if (!zone) { + syslog(LOG_ERR, "ical: unable to load UTC time zone!"); + } + return zone; +} + /* * Back end function for ical_dezonify() * - * We supply this with the master component and the property (which will - * be a DTSTART or DTEND) which we want to convert to UTC. + * We supply this with the master component, the relevant component, + * and the property (which will be a DTSTART, DTEND, etc.) + * which we want to convert to UTC. */ -void ical_dezonify_backend(icalcomponent *cal, icalproperty *prop) { - icaltimezone *t; +void ical_dezonify_backend(icalcomponent *cal, + icalcomponent *rcal, + icalproperty *prop) { + + icaltimezone *t = NULL; icalparameter *param; - const char *tzid; + const char *tzid = NULL; struct icaltimetype TheTime; + int utc_declared_as_tzid = 0; /**< Component declared 'TZID=GMT' instead of using Z syntax */ /* Give me nothing and I will give you nothing in return. */ if (cal == NULL) return; /* Hunt for a TZID parameter in this property. */ param = icalproperty_get_first_parameter(prop, ICAL_TZID_PARAMETER); - if (param == NULL) { - printf("No tzid parameter found - " - "perhaps this component is already UTC?\n"); - return; - } /* Get the stringish name of this TZID. */ - tzid = icalparameter_get_tzid(param); - if (tzid == NULL) { - printf("icalparameter_get_tzid() returned NULL\n"); - return; - } + if (param != NULL) { + tzid = icalparameter_get_tzid(param); + + /* Convert it to an icaltimezone type. */ + if (tzid != NULL) { + /* syslog(LOG_DEBUG, " * Stringy supplied timezone is: '%s'\n", tzid); */ + if ( (!strcasecmp(tzid, "UTC")) || (!strcasecmp(tzid, "GMT")) ) { + utc_declared_as_tzid = 1; + /* syslog(LOG_DEBUG, " * ...and we handle that internally.\n"); */ + } + else { + /* try attached first */ + t = icalcomponent_get_timezone(cal, tzid); +/* + syslog(LOG_DEBUG, " * ...and I %s have tzdata for that zone.\n", + (t ? "DO" : "DO NOT") + ); +*/ + /* then try built-in timezones */ + if (!t) { + t = icaltimezone_get_builtin_timezone(tzid); +/* + if (t) { + syslog(LOG_DEBUG, " * Using system tzdata!\n"); + } +*/ + } + } + } - /* Convert it to an icaltimezone type. */ - t = icalcomponent_get_timezone(cal, tzid); - if (t == NULL) { - printf("icalcomponent_get_timezone(%s) returned NULL\n", tzid); } /* Now we know the timezone. Convert to UTC. */ @@ -62,31 +123,70 @@ void ical_dezonify_backend(icalcomponent *cal, icalproperty *prop) { else if (icalproperty_isa(prop) == ICAL_DTEND_PROPERTY) { TheTime = icalproperty_get_dtend(prop); } + else if (icalproperty_isa(prop) == ICAL_DUE_PROPERTY) { + TheTime = icalproperty_get_due(prop); + } + else if (icalproperty_isa(prop) == ICAL_EXDATE_PROPERTY) { + TheTime = icalproperty_get_exdate(prop); + } + else { + return; + } - /* Do the conversion. - */ - icaltimezone_convert_time(&TheTime, - t, - icaltimezone_get_utc_timezone() - ); + /* syslog(LOG_DEBUG, " * Was: %s\n", icaltime_as_ical_string(TheTime)); */ - /* Now strip the TZID parameter, because it's incorrect now. */ - icalproperty_remove_parameter(prop, ICAL_TZID_PARAMETER); + if (icaltime_is_utc(TheTime)) { + /* syslog(LOG_DEBUG, " * This property is ALREADY UTC.\n"); */ + } + + else if (utc_declared_as_tzid) { + /* syslog(LOG_DEBUG, " * Replacing '%s' TZID with 'Z' suffix.\n", tzid); */ + TheTime.zone = icaltimezone_get_utc_timezone(); + } + + else { + /* Do the conversion. */ + if (t != NULL) { + /* syslog(LOG_DEBUG, " * Timezone prop found. Converting to UTC.\n"); */ + } + else { + /* syslog(LOG_DEBUG, " * Converting default timezone to UTC.\n"); */ + } + if (t == NULL) { + t = get_default_icaltimezone(); + } + + icaltimezone_convert_time(&TheTime, + t, + icaltimezone_get_utc_timezone() + ); + TheTime.zone = icaltimezone_get_utc_timezone(); + } + + icalproperty_remove_parameter_by_kind(prop, ICAL_TZID_PARAMETER); + /* syslog(LOG_DEBUG, " * Now: %s\n", icaltime_as_ical_string(TheTime)); */ + + /* Now add the converted property back in. */ if (icalproperty_isa(prop) == ICAL_DTSTART_PROPERTY) { icalproperty_set_dtstart(prop, TheTime); } else if (icalproperty_isa(prop) == ICAL_DTEND_PROPERTY) { icalproperty_set_dtend(prop, TheTime); } - + else if (icalproperty_isa(prop) == ICAL_DUE_PROPERTY) { + icalproperty_set_due(prop, TheTime); + } + else if (icalproperty_isa(prop) == ICAL_EXDATE_PROPERTY) { + icalproperty_set_exdate(prop, TheTime); + } } /* * Recursive portion of ical_dezonify() */ -void ical_dezonify_recur(icalcomponent *cal, icalcomponent *rcal) { +void ical_dezonify_recurse(icalcomponent *cal, icalcomponent *rcal) { icalcomponent *c; icalproperty *p; @@ -100,24 +200,24 @@ void ical_dezonify_recur(icalcomponent *cal, icalcomponent *rcal) { rcal, ICAL_ANY_COMPONENT) ) { if (icalcomponent_isa(c) != ICAL_VTIMEZONE_COMPONENT) { - ical_dezonify_recur(cal, c); + ical_dezonify_recurse(cal, c); } } /* * Now look for DTSTART and DTEND properties */ - for (p=icalcomponent_get_first_property( - rcal, ICAL_ANY_PROPERTY); + for (p=icalcomponent_get_first_property(rcal, ICAL_ANY_PROPERTY); p != NULL; - p = icalcomponent_get_next_property( - rcal, ICAL_ANY_PROPERTY) + p = icalcomponent_get_next_property(rcal, ICAL_ANY_PROPERTY) ) { if ( (icalproperty_isa(p) == ICAL_DTSTART_PROPERTY) || (icalproperty_isa(p) == ICAL_DTEND_PROPERTY) + || (icalproperty_isa(p) == ICAL_DUE_PROPERTY) + || (icalproperty_isa(p) == ICAL_EXDATE_PROPERTY) ) { - ical_dezonify_backend(cal, p); + ical_dezonify_backend(cal, rcal, p); } } } @@ -131,8 +231,10 @@ void ical_dezonify_recur(icalcomponent *cal, icalcomponent *rcal) { void ical_dezonify(icalcomponent *cal) { icalcomponent *vt = NULL; + /* syslog(LOG_DEBUG, "ical_dezonify() started\n"); */ + /* Convert all times to UTC */ - ical_dezonify_recur(cal, cal); + ical_dezonify_recurse(cal, cal); /* Strip out VTIMEZONE subcomponents -- we don't need them anymore */ while (vt = icalcomponent_get_first_component( @@ -140,6 +242,6 @@ void ical_dezonify(icalcomponent *cal) { icalcomponent_remove_component(cal, vt); icalcomponent_free(vt); } -} -#endif /* HAVE_ICAL_H */ + /* syslog(LOG_DEBUG, "ical_dezonify() completed\n"); */ +}