/**
* @brief
* Get the occurrence as defined by the given recurrence rule,
* index, and start time. This function assumes that the
* time dtsart passed in is the one to start the occurrence from.
*
* @par NOTE: This function should be made reentrant such that
* it can be looped over without having to loop over every occurrence
* over and over again.
*
* @param[in] rrule - The recurrence rule as defined by the user
* @param[in] dtstart - The start time from which to start
* @param[in] tz - The timezone associated to the recurrence rule
* @param[in] idx - The index of the occurrence to start counting from
*
* @return time_t
* @retval The date of the next occurrence or -1 if the date exceeds libical's
* Unix time in 2038
*
*/
time_t
get_occurrence(char *rrule, time_t dtstart, char *tz, int idx)
{
#ifdef LIBICAL
struct icalrecurrencetype rt;
struct icaltimetype start;
icaltimezone *localzone;
struct icaltimetype next;
struct icalrecur_iterator_impl *itr;
int i;
time_t next_occr = dtstart;
if (rrule == NULL)
return dtstart;
if (tz == NULL)
return -1;
icalerror_clear_errno();
icalerror_set_error_state(ICAL_PARSE_ERROR, ICAL_ERROR_NONFATAL);
#ifdef LIBICAL_API2
icalerror_set_errors_are_fatal(0);
#else
icalerror_errors_are_fatal = 0;
#endif
localzone = icaltimezone_get_builtin_timezone(tz);
if (localzone == NULL)
return -1;
rt = icalrecurrencetype_from_string(rrule);
start = icaltime_from_timet_with_zone(dtstart, 0, NULL);
icaltimezone_convert_time(&start, icaltimezone_get_utc_timezone(), localzone);
next = start;
itr = (struct icalrecur_iterator_impl*) icalrecur_iterator_new(rt, start);
/* Skip as many occurrences as specified by idx */
for (i = 0; i < idx && !icaltime_is_null_time(next); i++)
next = icalrecur_iterator_next(itr);
if (!icaltime_is_null_time(next)) {
icaltimezone_convert_time(&next, localzone,
icaltimezone_get_utc_timezone());
next_occr = icaltime_as_timet(next);
}
else next_occr = -1; /* If reached end of possible date-time return -1 */
icalrecur_iterator_free(itr);
return next_occr;
#else
return dtstart;
#endif
}
/** @brief Convert time to a given timezone
*
* Convert a time from its native timezone to a given timezone.
*
* If tt is a date, the returned time is an exact
* copy of the input. If it's a floating time, the returned object
* represents the same time translated to the given timezone.
* Otherwise the time will be converted to the new
* time zone, and its native timezone set to the right timezone.
*/
struct icaltimetype icaltime_convert_to_zone(const struct icaltimetype tt, icaltimezone *zone)
{
struct icaltimetype ret = tt;
/* If it's a date do nothing */
if (tt.is_date) {
return ret;
}
if (tt.zone == zone) {
return ret;
}
/* If it's a floating time we don't want to adjust the time */
if (tt.zone != NULL || tt.is_utc) {
icaltimezone *from_zone = (icaltimezone *) tt.zone;
if (!from_zone) {
from_zone = icaltimezone_get_utc_timezone();
}
icaltimezone_convert_time(&ret, from_zone, zone);
}
ret.zone = zone;
if (zone == icaltimezone_get_utc_timezone()) {
ret.is_utc = 1;
} else {
ret.is_utc = 0;
}
return ret;
}
/* Converts a time_t to a string, relative to the specified timezone */
static gchar *
timet_to_str_with_zone (ECalComponentDateTime *dt,
ECalClient *client,
icaltimezone *default_zone,
gboolean use_24_hour_format)
{
struct icaltimetype itt;
icaltimezone *zone = NULL;
struct tm tm;
gchar buf[256];
if (dt->tzid != NULL) {
e_cal_client_get_timezone_sync (
client, dt->tzid, &zone, NULL, NULL);
} else if (dt->value->is_utc) {
zone = icaltimezone_get_utc_timezone ();
}
itt = *dt->value;
if (zone != NULL)
icaltimezone_convert_time (&itt, zone, default_zone);
tm = icaltimetype_to_tm (&itt);
e_time_format_date_and_time (
&tm, use_24_hour_format,
FALSE, FALSE, buf, sizeof (buf));
return g_locale_to_utf8 (buf, -1, NULL, NULL, NULL);
}
/**
* @brief
* Returns the number of occurrences defined by a recurrence rule.
*
* @par The total number of occurrences is currently limited to a hardcoded
* 3 years limit from the current date.
*
* @par NOTE: Determine whether 3 years limit is the right way to go about setting
* a limit on the total number of occurrences.
*
* @param[in] rrule - The recurrence rule as defined by the user
* @param[in] tt - The start time of the first occurrence
* @param[in] tz - The timezone associated to the recurrence rule
*
* @return int
* @retval the total number of occurrences
*
*/
int
get_num_occurrences(char *rrule, time_t dtstart, char *tz)
{
#ifdef LIBICAL
struct icalrecurrencetype rt;
struct icaltimetype start;
icaltimezone *localzone;
struct icaltimetype next;
struct icalrecur_iterator_impl *itr;
time_t now;
time_t date_limit;
int num_resv = 0;
/* if any of the argument is NULL, we are dealing with
* advance reservation, so return 1 occurrence */
if (rrule == NULL || tz == NULL)
return 1;
icalerror_clear_errno();
icalerror_set_error_state(ICAL_PARSE_ERROR, ICAL_ERROR_NONFATAL);
icalerror_errors_are_fatal = 0;
localzone = icaltimezone_get_builtin_timezone(tz);
if (localzone == NULL)
return 0;
now = time((time_t *)0);
date_limit = now + DATE_LIMIT;
rt = icalrecurrencetype_from_string(rrule);
start = icaltime_from_timet(dtstart, 0);
icaltimezone_convert_time(&start, icaltimezone_get_utc_timezone(), localzone);
itr = (struct icalrecur_iterator_impl*) icalrecur_iterator_new(rt, start);
next = icalrecur_iterator_next(itr);
/* Compute the total number of occurrences.
* Breaks out if the total number of allowed occurrences is exceeded */
while (!icaltime_is_null_time(next) &&
(icaltime_as_timet(next) < date_limit)) {
num_resv++;
next = icalrecur_iterator_next(itr);
}
icalrecur_iterator_free(itr);
return num_resv;
#else
if (rrule == NULL)
return 1;
return 0;
#endif
}
nsresult calIcalProperty::setDatetime_(calIcalComponent * parent,
icalproperty * prop,
calIDateTime * dt)
{
NS_ENSURE_ARG_POINTER(prop);
NS_ENSURE_ARG_POINTER(dt);
nsresult rv;
nsCOMPtr<calIDateTimeLibical> icaldt = do_QueryInterface(dt, &rv);
NS_ENSURE_SUCCESS(rv, rv);
icaltimetype itt;
icaldt->ToIcalTime(&itt);
if (parent) {
if (!itt.is_utc) {
nsCOMPtr<calITimezone> tz;
rv = dt->GetTimezone(getter_AddRefs(tz));
NS_ENSURE_SUCCESS(rv, rv);
if (itt.zone) {
rv = parent->getParentVCalendarOrThis()->AddTimezoneReference(tz);
NS_ENSURE_SUCCESS(rv, rv);
icalparameter * const param = icalparameter_new_from_value_string(
ICAL_TZID_PARAMETER, icaltimezone_get_tzid(const_cast<icaltimezone *>(itt.zone)));
icalproperty_set_parameter(prop, param);
} else { // either floating or phantom:
bool b = false;
if (NS_FAILED(tz->GetIsFloating(&b)) || !b) {
// restore the same phantom TZID:
nsAutoCString tzid;
rv = tz->GetTzid(tzid);
NS_ENSURE_SUCCESS(rv, rv);
icalparameter * const param = icalparameter_new_from_value_string(ICAL_TZID_PARAMETER,
tzid.get());
icalproperty_set_parameter(prop, param);
}
}
}
} else if (!itt.is_date && !itt.is_utc && itt.zone) {
// no parent to add the CTIMEZONE to: coerce DATETIMEs to UTC, DATEs to floating
icaltimezone_convert_time(&itt,
const_cast<icaltimezone *>(itt.zone),
icaltimezone_get_utc_timezone());
itt.zone = icaltimezone_get_utc_timezone();
itt.is_utc = 1;
}
icalvalue * const val = icalvalue_new_datetime(itt);
CAL_ENSURE_MEMORY(val);
icalproperty_set_value(prop, val);
return NS_OK;
}
/**
* icaltimetype_to_tm_with_zone:
* @itt: A time value.
* @from_zone: Source timezone.
* @to_zone: Destination timezone.
*
* Converts a time value from one timezone to another, and returns a struct tm
* representation of the time.
*
* Return value: The converted time as a struct tm. All fields will be
* set properly except for tm.tm_yday.
**/
struct tm
icaltimetype_to_tm_with_zone (struct icaltimetype *itt,
icaltimezone *from_zone,
icaltimezone *to_zone)
{
struct tm tm;
struct icaltimetype itt_copy;
memset (&tm, 0, sizeof (tm));
tm.tm_isdst = -1;
g_return_val_if_fail (itt != NULL, tm);
itt_copy = *itt;
icaltimezone_convert_time (&itt_copy, from_zone, to_zone);
tm = icaltimetype_to_tm (&itt_copy);
return tm;
}
/* Converts a time_t to a string, relative to the specified timezone */
static gchar *
timet_to_str_with_zone (ECalComponentDateTime *dt,
ECalClient *client,
icaltimezone *default_zone)
{
struct icaltimetype itt;
icaltimezone *zone = NULL;
struct tm tm;
if (dt->tzid != NULL) {
e_cal_client_get_timezone_sync (
client, dt->tzid, &zone, NULL, NULL);
} else if (dt->value->is_utc) {
zone = icaltimezone_get_utc_timezone ();
}
itt = *dt->value;
if (zone != NULL)
icaltimezone_convert_time (&itt, zone, default_zone);
tm = icaltimetype_to_tm (&itt);
return e_datetime_format_format_tm ("calendar", "table", itt.is_date ? DTFormatKindDate : DTFormatKindDateTime, &tm);
}
NS_IMETHODIMP
calDateTime::GetInTimezone(calITimezone * aTimezone, calIDateTime ** aResult)
{
NS_ENSURE_ARG_POINTER(aTimezone);
NS_ENSURE_ARG_POINTER(aResult);
if (mIsDate) {
// if it's a date, we really just want to make a copy of this
// and set the timezone.
nsresult rv = Clone(aResult);
if (NS_SUCCEEDED(rv)) {
rv = (*aResult)->SetTimezone(aTimezone);
}
return rv;
} else {
icaltimetype icalt;
ToIcalTime(&icalt);
icaltimezone * tz = cal::getIcalTimezone(aTimezone);
if (icalt.zone == tz) {
return Clone(aResult);
}
/* If there's a zone, we need to convert; otherwise, we just
* assign, since this item is floating */
if (icalt.zone && tz) {
icaltimezone_convert_time(&icalt, const_cast<icaltimezone *>(icalt.zone), tz);
}
icalt.zone = tz;
icalt.is_utc = (tz && tz == icaltimezone_get_utc_timezone());
calDateTime * cdt = new calDateTime(&icalt, aTimezone);
CAL_ENSURE_MEMORY(cdt);
NS_ADDREF (*aResult = cdt);
return NS_OK;
}
}
/** Return the time as seconds past the UNIX epoch, using the
* given timezone.
*
* This convenience method combines a call to icaltime_convert_to_zone()
* with a call to icaltime_as_timet().
* If the input timezone is null, no conversion is done; that is, the
* time is simply returned as time_t in its native timezone.
*/
time_t icaltime_as_timet_with_zone(const struct icaltimetype tt, const icaltimezone *zone)
{
icaltimezone *utc_zone;
struct tm stm;
time_t t;
struct icaltimetype local_tt;
utc_zone = icaltimezone_get_utc_timezone();
/* If the time is the special null time, return 0. */
if (icaltime_is_null_time(tt)) {
return 0;
}
local_tt = tt;
/* Clear the is_date flag, so we can convert the time. */
local_tt.is_date = 0;
/* Use our timezone functions to convert to UTC. */
icaltimezone_convert_time(&local_tt, (icaltimezone *) zone, utc_zone);
/* Copy the icaltimetype to a struct tm. */
memset(&stm, 0, sizeof(struct tm));
stm.tm_sec = local_tt.second;
stm.tm_min = local_tt.minute;
stm.tm_hour = local_tt.hour;
stm.tm_mday = local_tt.day;
stm.tm_mon = local_tt.month - 1;
stm.tm_year = local_tt.year - 1900;
stm.tm_isdst = -1;
t = icaltime_timegm(&stm);
return t;
}
/** @brief Constructor.
*
* @param tm The time
* @param is_date Boolean: 1 means we should treat tm as a DATE
* @param zone The timezone tm is in, NULL means to treat tm as a
* floating time
*
* Return a new icaltime instance, initialized to the given time
* expressed as seconds past UNIX epoch, optionally using the given
* timezone.
*
* If the caller specifies the is_date param as TRUE, the returned
* object is of DATE type, otherwise the input is meant to be of
* DATE-TIME type.
* If the zone is not specified (NULL zone param) the time is taken
* to be floating, that is, valid in any timezone. Note that, in
* addition to the uses specified in [RFC5545], this can be used
* when doing simple math on couples of times.
* If the zone is specified (UTC or otherwise), it's stored in the
* object and it's used as the native timezone for this object.
* This means that the caller can convert this time to a different
* target timezone with no need to store the source timezone.
*
*/
struct icaltimetype icaltime_from_timet_with_zone(const time_t tm, const int is_date,
const icaltimezone *zone)
{
struct icaltimetype tt;
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. */
gmtime_r(&tm, &t);
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_date = 0;
tt.is_utc = (zone == utc_zone) ? 1 : 0;
tt.is_daylight = 0;
tt.zone = NULL;
/* Use our timezone functions to convert to the required timezone. */
icaltimezone_convert_time(&tt, utc_zone, (icaltimezone *) zone);
tt.is_date = is_date;
/* If it is a DATE value, make sure hour, minute & second are 0. */
if (is_date) {
tt.hour = 0;
tt.minute = 0;
tt.second = 0;
}
return tt;
}
static ECellDateEditValue *
get_dtend (ECalModelCalendar *model,
ECalModelComponent *comp_data)
{
struct icaltimetype tt_end;
if (!comp_data->dtend) {
icalproperty *prop;
icaltimezone *zone = NULL, *model_zone = NULL;
gboolean got_zone = FALSE;
prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_DTEND_PROPERTY);
if (!prop)
return NULL;
tt_end = icalproperty_get_dtend (prop);
if (icaltime_get_tzid (tt_end)
&& e_cal_client_get_timezone_sync (comp_data->client, icaltime_get_tzid (tt_end), &zone, NULL, NULL))
got_zone = TRUE;
model_zone = e_cal_model_get_timezone (E_CAL_MODEL (model));
if (got_zone) {
tt_end = icaltime_from_timet_with_zone (comp_data->instance_end, tt_end.is_date, zone);
if (model_zone)
icaltimezone_convert_time (&tt_end, zone, model_zone);
} else {
tt_end = icaltime_from_timet_with_zone (
comp_data->instance_end,
tt_end.is_date, model_zone);
}
if (!icaltime_is_valid_time (tt_end) || icaltime_is_null_time (tt_end))
return NULL;
if (tt_end.is_date && icalcomponent_get_first_property (comp_data->icalcomp, ICAL_DTSTART_PROPERTY)) {
struct icaltimetype tt_start;
icaltimezone *start_zone = NULL;
gboolean got_start_zone = FALSE;
tt_start = icalproperty_get_dtstart (prop);
if (icaltime_get_tzid (tt_start)
&& e_cal_client_get_timezone_sync (comp_data->client, icaltime_get_tzid (tt_start), &start_zone, NULL, NULL))
got_start_zone = TRUE;
if (got_start_zone) {
tt_start = icaltime_from_timet_with_zone (comp_data->instance_start, tt_start.is_date, start_zone);
if (model_zone)
icaltimezone_convert_time (&tt_start, start_zone, model_zone);
} else {
tt_start = icaltime_from_timet_with_zone (
comp_data->instance_start,
tt_start.is_date, model_zone);
}
icaltime_adjust (&tt_start, 1, 0, 0, 0);
/* Decrease by a day only if the DTSTART will still be before, or the same as, DTEND */
if (icaltime_compare (tt_start, tt_end) <= 0)
icaltime_adjust (&tt_end, -1, 0, 0, 0);
}
comp_data->dtend = g_new0 (ECellDateEditValue, 1);
comp_data->dtend->tt = tt_end;
if (got_zone)
comp_data->dtend->zone = zone;
else
comp_data->dtend->zone = NULL;
}
return e_cal_model_copy_cell_date_value (comp_data->dtend);
}
static void
dump_local_times (icaltimezone *zone, FILE *fp)
{
static char *months[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
icaltimezone *utc_timezone;
struct icaltimetype tt, tt_copy;
struct tm tm, local_tm;
time_t t;
char tzstring[256], *location;
int last_year_output = 0;
int total_error = 0, total_error2 = 0;
utc_timezone = icaltimezone_get_utc_timezone ();
/* This is our UTC time that we will use to iterate over the period. */
tt.year = DUMP_START_YEAR;
tt.month = 1;
tt.day = 1;
tt.hour = 0;
tt.minute = 0;
tt.second = 0;
tt.is_utc = 0;
tt.is_date = 0;
tt.zone = "";
tm.tm_year = tt.year - 1900;
tm.tm_mon = tt.month - 1;
tm.tm_mday = tt.day;
tm.tm_hour = tt.hour;
tm.tm_min = tt.minute;
tm.tm_sec = tt.second;
tm.tm_isdst = -1;
/* Convert it to a time_t by saying it is in UTC. */
putenv ("TZ=UTC");
t = mktime (&tm);
location = icaltimezone_get_location (zone);
sprintf (tzstring, "TZ=%s", location);
/*printf ("Zone: %s\n", location);*/
putenv (tzstring);
/* Loop around converting the UTC time to local time, outputting it, and
then adding on 15 minutes to the UTC time. */
while (tt.year <= DUMP_END_YEAR) {
if (tt.year > last_year_output) {
last_year_output = tt.year;
#if 0
printf (" %i\n", last_year_output);
fprintf (fp, " %i\n", last_year_output);
#endif
}
#if 1
/* First use the Unix functions. */
/* Now convert it to a local time in the given timezone. */
local_tm = *localtime (&t);
#endif
#if 1
/* Now use libical. */
tt_copy = tt;
icaltimezone_convert_time (&tt_copy, utc_timezone, zone);
#endif
#if 1
if (local_tm.tm_year + 1900 != tt_copy.year
|| local_tm.tm_mon + 1 != tt_copy.month
|| local_tm.tm_mday != tt_copy.day
|| local_tm.tm_hour != tt_copy.hour
|| local_tm.tm_min != tt_copy.minute
|| local_tm.tm_sec != tt_copy.second) {
/* The error format is:
ERROR: Original-UTC-Time Local-Time-From-mktime Local-Time-From-Libical
*/
total_error++;
fprintf (fp, "ERROR:%2i %s %04i %2i:%02i:%02i UTC",
tt.day, months[tt.month - 1], tt.year,
tt.hour, tt.minute, tt.second);
fprintf (fp, " ->%2i %s %04i %2i:%02i:%02i",
local_tm.tm_mday, months[local_tm.tm_mon],
local_tm.tm_year + 1900,
local_tm.tm_hour, local_tm.tm_min, local_tm.tm_sec);
fprintf (fp, " Us:%2i %s %04i %2i:%02i:%02i\n",
tt_copy.day, months[tt_copy.month - 1], tt_copy.year,
tt_copy.hour, tt_copy.minute, tt_copy.second);
}
#endif
/* Now convert it back, and check we get the original time. */
icaltimezone_convert_time (&tt_copy, zone, utc_timezone);
if (tt.year != tt_copy.year
|| tt.month != tt_copy.month
|| tt.day != tt_copy.day
|| tt.hour != tt_copy.hour
|| tt.minute != tt_copy.minute
|| tt.second != tt_copy.second) {
total_error2++;
fprintf (fp, "ERROR 2: %2i %s %04i %2i:%02i:%02i UTC",
tt.day, months[tt.month - 1], tt.year,
tt.hour, tt.minute, tt.second);
fprintf (fp, " Us:%2i %s %04i %2i:%02i:%02i UTC\n",
tt_copy.day, months[tt_copy.month - 1], tt_copy.year,
tt_copy.hour, tt_copy.minute, tt_copy.second);
}
/* Increment the time. */
icaltime_adjust (&tt, 0, 0, 15, 0);
/* We assume leap seconds are not included in time_t values, which should
be true on POSIX systems. */
t += 15 * 60;
}
printf ("Zone: %40s Errors: %i (%i)\n", icaltimezone_get_location (zone),
total_error, total_error2);
}
/**
* @brief
* Check if a recurrence rule is valid and consistent.
* The recurrence rule is verified against a start date and checks
* that the frequency of the recurrence matches the duration of the
* submitted reservation. If the duration of a reservation exceeds the
* granularity of the frequency then an error message is displayed.
*
* @par The recurrence rule is checked to contain a COUNT or an UNTIL.
*
* @par Note that the PBS_TZID environment variable HAS to be set for the occurrence's
* dates to be correctly computed.
*
* @param[in] rrule - The recurrence rule to unroll
* @param[in] dtstart - The start time associated to the reservation (1st occurrence)
* @param[in] dtend - The end time associated to the reservation (1st occurrence)
* @param[in] duration - The duration of an occurrence. This is used when a reservation is
* submitted using the -D (duration) param instead of an end time
* @param[in] tz - The timezone associated to the recurrence rule
* @param[in] err_code - A pointer to the error code to return. Codes are defined in pbs_error.h
*
* @return int
* @retval The total number of occurrences that the recurrence rule and start date
*
* define. 1 for an advance reservation.
*
*/
int
check_rrule(char *rrule, time_t dtstart, time_t dtend, char *tz, int *err_code)
{
#ifdef LIBICAL /* Standing Reservation Recurrence */
int count = 1;
struct icalrecurrencetype rt;
struct icaltimetype start;
struct icaltimetype next;
struct icaltimetype first;
struct icaltimetype prev;
struct icalrecur_iterator_impl *itr;
icaltimezone *localzone;
int time_err = 0;
int i;
long min_occr_duration = -1;
long tmp_occr_duration = 0;
long duration;
*err_code = 0;
icalerror_clear_errno();
icalerror_set_error_state(ICAL_PARSE_ERROR, ICAL_ERROR_NONFATAL);
icalerror_errors_are_fatal = 0;
if (tz == NULL || rrule == NULL)
return 0;
localzone = icaltimezone_get_builtin_timezone(tz);
/* If the timezone info directory is not accessible
* then bail
*/
if (localzone == NULL) {
*err_code = PBSE_BAD_ICAL_TZ;
return 0;
}
rt = icalrecurrencetype_from_string(rrule);
/* Check if by_day rules are defined and valid
* the first item in the array of by_* rule
* determines whether the item exists or not.
*/
for (i = 0; rt.by_day[i] < 8; i++) {
if (rt.by_day[i] <= 0) {
*err_code = PBSE_BAD_RRULE_SYNTAX;
return 0;
}
}
/* Check if by_hour rules are defined and valid
* the first item in the array of by_* rule
* determines whether the item exists or not.
*/
for (i = 0; rt.by_hour[i] < 25; i++) {
if (rt.by_hour[i] < 0) {
*err_code = PBSE_BAD_RRULE_SYNTAX;
return 0;
}
}
/* Check if the rest of the by_* rules are defined
* and valid.
* currently no support for
* BYMONTHDAY, BYYEARDAY, BYSECOND,
* BYMINUTE, BYWEEKNO, or BYSETPOS
*
*/
if (rt.by_second[0] < 61 || /* by_second is negative such as in -10 */
rt.by_minute[0] < 61 || /* by_minute is negative such as in -10 */
rt.by_year_day[0] < 367 || /* a year day is defined */
rt.by_month_day[0] < 31 || /* a month day is defined */
rt.by_week_no[0] < 52 || /* a week number is defined */
rt.by_set_pos[0] < 367) { /* a set pos is defined */
*err_code = PBSE_BAD_RRULE_SYNTAX;
return 0;
}
/* Require that either a COUNT or UNTIL be passed. But not both. */
if ((rt.count == 0 && icaltime_is_null_time(rt.until)) ||
(rt.count != 0 && !icaltime_is_null_time(rt.until))) {
*err_code = PBSE_BAD_RRULE_SYNTAX2; /* Undefined iCalendar synax. A valid COUNT or UNTIL is required */
return 0;
}
start = icaltime_from_timet(dtstart, 0);
icaltimezone_convert_time(&start, icaltimezone_get_utc_timezone(), localzone);
itr = (struct icalrecur_iterator_impl*) icalrecur_iterator_new(rt, start);
duration = dtend -dtstart;
/* First check if the syntax of the iCalendar rule is valid */
next = icalrecur_iterator_next(itr);
/* Catch case where first occurrence date is in the past */
if (icaltime_is_null_time(next)) {
*err_code = PBSE_BADTSPEC;
icalrecur_iterator_free(itr);
return 0;
}
first = next;
prev = first;
for (next=icalrecur_iterator_next(itr); !icaltime_is_null_time(next); next=icalrecur_iterator_next(itr), count++) {
/* The interval duration between two occurrences
* is the time between the end of an occurrence and the
* start of the next one
*/
tmp_occr_duration = icaltime_as_timet(next) - icaltime_as_timet(prev);
/* Set the minimum time interval between occurrences */
if (min_occr_duration == -1)
min_occr_duration = tmp_occr_duration;
else if (tmp_occr_duration > 0 &&
tmp_occr_duration < min_occr_duration)
min_occr_duration = tmp_occr_duration;
prev = next;
}
/* clean up */
icalrecur_iterator_free(itr);
if (icalerrno != ICAL_NO_ERROR) {
*err_code = PBSE_BAD_RRULE_SYNTAX; /* Undefined iCalendar syntax */
return 0;
}
/* Then check if the duration fits in the frequency rule */
switch (rt.freq) {
case ICAL_SECONDLY_RECURRENCE:
{
if (duration > 1) {
#ifdef NAS /* localmod 005 */
icalerrno = ICAL_BADARG_ERROR;
#else
icalerrno = 1;
#endif /* localmod 005 */
*err_code = PBSE_BAD_RRULE_SECONDLY; /* SECONDLY recurrence duration cannot exceed 1 second */
time_err++;
}
break;
}
case ICAL_MINUTELY_RECURRENCE:
{
if (duration > 60) {
#ifdef NAS /* localmod 005 */
icalerrno = ICAL_BADARG_ERROR;
#else
icalerrno = 1;
#endif /* localmod 005 */
*err_code = PBSE_BAD_RRULE_MINUTELY; /* MINUTELY recurrence duration cannot exceed 1 minute */
time_err++;
}
break;
}
case ICAL_HOURLY_RECURRENCE:
{
if (duration > (60*60)) {
#ifdef NAS /* localmod 005 */
icalerrno = ICAL_BADARG_ERROR;
#else
icalerrno =1;
#endif /* localmod 005 */
*err_code = PBSE_BAD_RRULE_HOURLY; /* HOURLY recurrence duration cannot exceed 1 hour */
time_err++;
}
break;
}
case ICAL_DAILY_RECURRENCE:
{
if (duration > (60*60*24)) {
#ifdef NAS /* localmod 005 */
icalerrno = ICAL_BADARG_ERROR;
#else
icalerrno = 1;
#endif /* localmod 005 */
*err_code = PBSE_BAD_RRULE_DAILY; /* DAILY recurrence duration cannot exceed 24 hours */
time_err++;
}
break;
}
case ICAL_WEEKLY_RECURRENCE:
{
if (duration > (60*60*24*7)) {
#ifdef NAS /* localmod 005 */
icalerrno = ICAL_BADARG_ERROR;
#else
icalerrno = 1;
#endif /* localmod 005 */
*err_code = PBSE_BAD_RRULE_WEEKLY; /* WEEKLY recurrence duration cannot exceed 1 week */
time_err++;
}
break;
}
case ICAL_MONTHLY_RECURRENCE:
{
if (duration > (60*60*24*30)) {
#ifdef NAS /* localmod 005 */
icalerrno = ICAL_BADARG_ERROR;
#else
icalerrno = 1;
#endif /* localmod 005 */
*err_code = PBSE_BAD_RRULE_MONTHLY; /* MONTHLY recurrence duration cannot exceed 1 month */
time_err++;
}
break;
}
case ICAL_YEARLY_RECURRENCE:
{
if (duration > (60*60*24*30*365)) {
#ifdef NAS /* localmod 005 */
icalerrno = ICAL_BADARG_ERROR;
#else
icalerrno = 1;
#endif /* localmod 005 */
*err_code = PBSE_BAD_RRULE_YEARLY; /* YEARLY recurrence duration cannot exceed 1 year */
time_err++;
}
break;
}
default:
{
icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
return 0;
}
}
if (time_err)
return 0;
/* If the requested reservation duration exceeds
* the occurrence's duration then print an error
* message and return */
if (count != 1 && duration > min_occr_duration) {
*err_code = PBSE_BADTSPEC; /* Bad Time Specification(s) */
return 0;
}
return count;
#else
*err_code = PBSE_BAD_RRULE_SYNTAX; /* iCalendar is undefined */
return 0;
#endif
}
