X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=webcit-ng%2Fserver%2Fcaldav_reports.c;h=485b2a3eb0647ff368976f53d53803a07cb2fa52;hb=dc7628bd87467c18ac7c4a7e241d536a1d0ffb22;hp=b28554e0c5c8ea9ec7ed515c88db21c59d6a2fcb;hpb=f6edf9b754dcd04e8eab7fa53dc62b57ad5b14cc;p=citadel.git diff --git a/webcit-ng/server/caldav_reports.c b/webcit-ng/server/caldav_reports.c index b28554e0c..485b2a3eb 100644 --- a/webcit-ng/server/caldav_reports.c +++ b/webcit-ng/server/caldav_reports.c @@ -4,6 +4,11 @@ #include "webcit.h" +#define CALDAV "urn:ietf:params:xml:ns:caldav:" // Shorthand for the XML namespace of CalDAV +#define CALDAVLEN sizeof(CALDAV)-1 // And the length of that string + +const char *the_beginning_of_time = "19010101T010101Z"; +const char *the_end_of_time = "99991231T235959Z"; // A CalDAV REPORT can only be one type. This is stored in the report_type member. enum cr_type { @@ -12,16 +17,16 @@ enum cr_type { cr_freebusy_query }; - // Data type for CalDAV Report Parameters. // As we slog our way through the XML we learn what the client is asking for // and build up the contents of this data type. struct cr_params { - int tag_nesting_level; // not needed, just kept for pretty-printing + int comp_filter_nesting_level; enum cr_type report_type; // which RFC4791 section 7 REPORT are we generating StrBuf *Chardata; // XML chardata in between tags is built up here StrBuf *Hrefs; // list of items requested by a `calendar-multiget` REPORT Array *filters; // If the query contains a FILTER stanza, the filter criteria are populated here + int filter_nest; // tag nesting level where a FILTER stanza begins }; @@ -31,90 +36,57 @@ void caldav_xml_start(void *data, const char *el, const char **attr) { #ifdef DEBUG_XML_PARSE // logging - int i; - char indent[256]; - indent[0] = 0; - for (i=0; itag_nesting_level; ++i) { - strcat(indent, " "); - } - syslog(LOG_DEBUG, "%s<%s>", indent, el); - ++crp->tag_nesting_level; - indent[0] = 0; - for (i=0; itag_nesting_level; ++i) { - strcat(indent, " "); - } - for (i = 0; attr[i] != NULL; i += 2) { - syslog(LOG_DEBUG, "%sAttribute '%s' = '%s'", indent, attr[i], attr[i + 1]); + syslog(LOG_DEBUG, "<%s>", el); + for (int i = 0; attr[i] != NULL; i += 2) { + syslog(LOG_DEBUG, "Attribute '%s' = '%s'", attr[i], attr[i + 1]); } // end logging #endif // RFC4791 7.8 "calendar-query" REPORT - Client will send a lot of search criteria. - if (!strcasecmp(el, "urn:ietf:params:xml:ns:caldav:calendar-query")) { + if (!strcasecmp(el, CALDAV"calendar-query")) { crp->report_type = cr_calendar_query; } // RFC4791 7.9 "calendar-multiget" REPORT - Client will supply a list of specific hrefs. - else if (!strcasecmp(el, "urn:ietf:params:xml:ns:caldav:calendar-multiget")) { + else if (!strcasecmp(el, CALDAV"calendar-multiget")) { crp->report_type = cr_calendar_multiget; } // RFC4791 7.10 "free-busy-query" REPORT - else if (!strcasecmp(el, "urn:ietf:params:xml:ns:caldav:free-busy-query")) { + else if (!strcasecmp(el, CALDAV"free-busy-query")) { crp->report_type = cr_freebusy_query; } - // RFC4791 9.7 create a filter array if this query contains a "CALDAV:filter" stanza - else if (!strcasecmp(el, "urn:ietf:params:xml:ns:caldav:filter")) { + // RFC4791 9.7 create a filter array if this query contains a "filter" stanza + else if (!strcasecmp(el, CALDAV"filter")) { crp->filters = array_new(SIZ); - } - - // RFC4791 9.7.1 CALDAV:comp-filter XML Element - else if ( (!strcasecmp(el, "urn:ietf:params:xml:ns:caldav:comp-filter")) - && (crp->filters) - && (attr[0]) - && (attr[1]) + crp->filter_nest = crp->comp_filter_nesting_level; + } + + // Handle the filters defined in RFC4791 9.7.1 through 9.7.5 + else if ( ( (!strcasecmp(el, CALDAV"comp-filter")) + || (!strcasecmp(el, CALDAV"prop-filter")) + || (!strcasecmp(el, CALDAV"param-filter")) + || (!strcasecmp(el, CALDAV"is-not-defined")) + || (!strcasecmp(el, CALDAV"text-match")) + || (!strcasecmp(el, CALDAV"time-range")) + ) + && (crp->filters) // Make sure we actually allocated an array ) { - char newfilter[SIZ]; - snprintf(newfilter, SIZ, "comp-filter|%s|%s", attr[0], attr[1]); - array_append(crp->filters, newfilter); - syslog(LOG_DEBUG, "%s", newfilter); - } - // RFC4791 9.7.2 CALDAV:prop-filter XML Element - else if (!strcasecmp(el, "urn:ietf:params:xml:ns:caldav:prop-filter")) { - if (crp->filters) { - char newfilter[SIZ]; - snprintf(newfilter, SIZ, "hi there"); - array_append(crp->filters, newfilter); + if (!strcasecmp(el, CALDAV"comp-filter")) { + ++crp->comp_filter_nesting_level; } - } - - // RFC4791 9.7.3 CALDAV:param-filter XML Element - else if (!strcasecmp(el, "urn:ietf:params:xml:ns:caldav:param-filter")) { - if (crp->filters) { - char newfilter[SIZ]; - snprintf(newfilter, SIZ, "hi there"); - array_append(crp->filters, newfilter); - } - } - - // RFC4791 9.7.4 CALDAV:is-not-defined XML Element - else if (!strcasecmp(el, "urn:ietf:params:xml:ns:caldav:is-not-defined")) { - if (crp->filters) { - char newfilter[SIZ]; - snprintf(newfilter, SIZ, "hi there"); - array_append(crp->filters, newfilter); - } - } - // RFC4791 9.7.5 CALDAV:text-match XML Element - else if (!strcasecmp(el, "urn:ietf:params:xml:ns:caldav:text-match")) { - if (crp->filters) { - char newfilter[SIZ]; - snprintf(newfilter, SIZ, "hi there"); - array_append(crp->filters, newfilter); + char newfilter[SIZ]; + int a = 0; + int len = snprintf(newfilter, SIZ, "%d|", crp->comp_filter_nesting_level - crp->filter_nest - 1); + len += snprintf(&newfilter[len], SIZ-len, "%s", &el[CALDAVLEN]); // filter name without the namespace + while (attr[a]) { + len += snprintf(&newfilter[len], SIZ-len, "|%s", attr[a++]); // now save the attributes } + array_append(crp->filters, newfilter); } } @@ -123,20 +95,18 @@ void caldav_xml_start(void *data, const char *el, const char **attr) { void caldav_xml_end(void *data, const char *el) { struct cr_params *crp = (struct cr_params *) data; - --crp->tag_nesting_level; - #ifdef DEBUG_XML_PARSE // logging int i; - char indent[256]; - indent[0] = 0; - for (i=0; itag_nesting_level; ++i) { - strcat(indent, " "); - } - syslog(LOG_DEBUG, "%s", indent, el); + syslog(LOG_DEBUG, "", el); // end logging #endif + if (!strcasecmp(el, CALDAV"comp-filter")) { + --crp->comp_filter_nesting_level; + } + + if ((!strcasecmp(el, "DAV::href")) || (!strcasecmp(el, "DAV:href"))) { if (crp->Hrefs == NULL) { // append crp->Chardata to crp->Hrefs crp->Hrefs = NewStrBuf(); @@ -176,12 +146,7 @@ void caldav_xml_chardata(void *data, const XML_Char *s, int len) { string_trim(app); // remove leading/trailing whitespace. ok to mangle it because we've already appended. if (!IsEmptyStr(app)) { int i; - char indent[256]; - indent[0] = 0; - for (i=0; itag_nesting_level; ++i) { - strcat(indent, " "); - } - syslog(LOG_DEBUG, "%s%s", indent, app, len); + syslog(LOG_DEBUG, "%s", app, len); } // end logging #endif @@ -293,8 +258,192 @@ void caldav_report_one_item(struct http_transaction *h, struct ctdlsession *c, S } -void caldav_apply_filter(struct cr_params *crp, char *xml_body, long xml_length) { - TRACE; +// Compare function for "time-range" tests (RFC4791 section 9.9) +// Returns nonzero if the supplied icalcomponent occurs within the specified time range +// +// IMPLEMENTATION NOTE: +// ical_ctdl_is_overlap() works because icaltime_compare() is really smart. +// It looks at the time zone of the dtstart/dtend and can apparently go back up the icalcomponent +// hierarchy to find its time zone data. I tested this by creating an event with a fictional +// time zone and it did the right thing. It even showed the fictional name to me. This saves us +// from having to convert everything to UTC before comparing. Nice! +// +int caldav_time_range_filter_matches(icalcomponent *cal, char *start_str, char *end_str) { + + struct icaltimetype search_start = icaltime_from_string(start_str); // time range being searched + struct icaltimetype search_end = icaltime_from_string(end_str); + + struct icaltimetype dtstart = icalcomponent_get_dtstart(cal); // time of event + struct icaltimetype dtend = icalcomponent_get_dtend(cal); + if (icaltime_is_null_time(dtend)) { + dtend = dtstart; + } + + // If it is a recurring event, RRULE is available at this level. We can handle it here. + icalproperty *rrule = icalcomponent_get_first_property(cal, ICAL_RRULE_PROPERTY); + if (rrule) { + struct icaldurationtype dur = icaltime_subtract(dtend, dtstart); // recurrences need duration to find dtend + struct icalrecurrencetype recur = icalproperty_get_rrule(rrule); + icalrecur_iterator *ritr = icalrecur_iterator_new(recur, dtstart); // iterate through recurrences + while (dtstart = icalrecur_iterator_next(ritr), !icaltime_is_null_time(dtstart)) { + dtend = icaltime_add(dtstart, dur); + + // Does THIS recurrence match the query? If so, free the memory we used and stop iterating. + if (ical_ctdl_is_overlap(dtstart, dtend, search_start, search_end)) { + icalrecur_iterator_free(ritr); + return(1); + } + } + + icalrecur_iterator_free(ritr); + return(0); // compared all recurrences, no match was found for any of them + } + + // For non recurring events, do a simple time range compare. + return(ical_ctdl_is_overlap(dtstart, dtend, search_start, search_end)); // We have a convenience function for this. +} + + +// Recursive function to apply CalDAV FILTERS to a calendar item. +// Returns zero if the calendar item was disqualified by a filter, nonzero if the calendar item still qualifies. +int caldav_apply_filters(void *cal, Array *filters, int apply_at_level) { + + int f = 0; // filter number iterator + int qual = 1; // 0 for disqualify, 1 for qualify + int previous_level = -1; + int disregard_further_comp_filters = 0; + + while ( (f", f, this_rule_level, array_get_element_at(filters, f) ); + + // Handle the individual filters defined in RFC4791 9.7.1 through 9.7.5 + + if (apply_at_level < previous_level) { + syslog(LOG_DEBUG, "caldav: walking back down"); + return(qual); + } + + else if (this_rule_level != apply_at_level) { + syslog(LOG_DEBUG, "caldav: apply_at_level=%d, this_rule_level=%d, skipping this rule", apply_at_level, this_rule_level); + } + + else if ( (!strcasecmp(t[1], "comp-filter")) // RFC4791 9.7.1 - filter by component + && (!disregard_further_comp_filters) // one is enough to succeed + ) { + syslog(LOG_DEBUG, "component filter at level %d", this_rule_level); + + // comp-filter requires exactly one parameter (name="VXXXX") + if (num_tokens < 4) { + syslog(LOG_DEBUG, "caldav: comp-filter has no parameters - rejecting"); + return(0); + } + + // Root element is NOT a component, but the root filter is "comp-filter" -- reject! + if ( (!icalcomponent_isa_component(cal)) && (this_rule_level == 0) ) { + syslog(LOG_DEBUG, "caldav: root element is not a component, rejecting"); + return(0); + } + + // Current element is a component and the filter is "comp-filter" -- see if it matches the requested type + if ( (icalcomponent_isa_component(cal)) + && (!strcasecmp(t[2], "name")) + ) { + if (icalcomponent_isa(cal) == icalcomponent_string_to_kind(t[3]) ) { + syslog(LOG_DEBUG, "caldav: component at level %d is <%s>, looking for <%s>, recursing...", + apply_at_level, + icalcomponent_kind_to_string(icalcomponent_isa(cal)), t[3] + ); + + // We have a match. Drill down into the subcomponents. + + icalcomponent *c = NULL; + int number_of_subcomponents = 0; + int number_of_matches = 0; + for ( c = icalcomponent_get_first_component(cal, ICAL_ANY_COMPONENT); + (c != 0); + c = icalcomponent_get_next_component(cal, ICAL_ANY_COMPONENT) + ) { + ++number_of_subcomponents; + if (caldav_apply_filters(c, filters, apply_at_level+1)) { + syslog(LOG_DEBUG, "Subcomponent %d might match", number_of_subcomponents); + ++number_of_matches; + } + } + if (number_of_matches > 0) { // something matched + qual = 1; + disregard_further_comp_filters = 1; + + } + else if (number_of_subcomponents > 0) { // nothing matched + return(0); // but only fail if there *were* subcomponents. + } + + } + else { + syslog(LOG_DEBUG, "caldav: component at level %d is <%s>, looking for <%s>, rejecting", + apply_at_level, + icalcomponent_kind_to_string(icalcomponent_isa(cal)), + t[3] + ); + return(0); + } + } + + } + + else if (!strcasecmp(t[1], "prop-filter")) { // RFC4791 9.7.2 - filter by property + syslog(LOG_DEBUG, "property filter at level %d FIXME not implemented yet", this_rule_level); + } + + else if (!strcasecmp(t[1], "param-filter")) { // RFC4791 9.7.3 - filter by parameter + syslog(LOG_DEBUG, "parameter filter at level %d FIXME not implemented yet", this_rule_level); + } + + else if (!strcasecmp(t[1], "is-not-defined")) { // RFC4791 9.7.4 + syslog(LOG_DEBUG, "is-not-defined filter at level %d FIXME not implemented yet", this_rule_level); + } + + else if (!strcasecmp(t[1], "text-match")) { // RFC4791 9.7.5 + syslog(LOG_DEBUG, "text match filter at level %d FIXME not implemented yet", this_rule_level); + } + + else if (!strcasecmp(t[1], "time-range")) { // RFC4791 9.9 + syslog(LOG_DEBUG, "time range filter at level %d FIXME add recurrence", this_rule_level); + for (int i=2; (i+1)