X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Fmodules%2Fcalendar%2Fserv_calendar.c;h=e1e02ae544b0caf6c73704ec66cb2675e51d1422;hb=63262a64633e72e4096aaeedda6950c02fb4d990;hp=3d63bcdc26cf8fe2a3e7908f51899bb4a9557ca2;hpb=85ae093a7401ea30ff071d833c6456ab8880ad15;p=citadel.git diff --git a/citadel/modules/calendar/serv_calendar.c b/citadel/modules/calendar/serv_calendar.c index 3d63bcdc2..e1e02ae54 100644 --- a/citadel/modules/calendar/serv_calendar.c +++ b/citadel/modules/calendar/serv_calendar.c @@ -5,34 +5,34 @@ * room on a Citadel server. It handles iCalendar objects using the * iTIP protocol. See RFCs 2445 and 2446. * + * + * Copyright (c) 1987-2009 by the citadel.org team + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * 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. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #define PRODID "-//Citadel//NONSGML Citadel Calendar//EN" -#include "sysdep.h" -#include -#include -#include -#include -#include -#include -#ifdef HAVE_STRINGS_H -#include -#endif +#include "ctdl_module.h" + #include -#include -#include "citadel.h" -#include "server.h" -#include "citserver.h" -#include "support.h" -#include "config.h" -#include "user_ops.h" -#include "room_ops.h" + #include "msgbase.h" #include "internet_addressing.h" #include "serv_calendar.h" #include "euidindex.h" -#include "ctdl_module.h" #include "ical_dezonify.h" @@ -316,7 +316,8 @@ void ical_send_a_reply(icalcomponent *request, char *action) { /* * Callback function for mime parser that hunts for calendar content types - * and turns them into calendar objects + * and turns them into calendar objects. If something is found, it is placed + * in ird->cal, and the caller now owns that memory and is responsible for freeing it. */ void ical_locate_part(char *name, char *filename, char *partnum, char *disp, void *content, char *cbtype, char *cbcharset, size_t length, char *encoding, @@ -599,8 +600,8 @@ int ical_update_my_calendar_with_reply(icalcomponent *cal) { strcpy(hold_rm, CC->room.QRname); /* save current room */ - if (getroom(&CC->room, USERCALENDARROOM) != 0) { - getroom(&CC->room, hold_rm); + if (CtdlGetRoom(&CC->room, USERCALENDARROOM) != 0) { + CtdlGetRoom(&CC->room, hold_rm); CtdlLogPrintf(CTDL_CRIT, "cannot get user calendar room\n"); return(2); } @@ -611,9 +612,9 @@ int ical_update_my_calendar_with_reply(icalcomponent *cal) { * Citadel always sets the message EUID to the iCalendar UID of * the event, this will work. */ - msgnum_being_replaced = locate_message_by_euid(uid, &CC->room); + msgnum_being_replaced = CtdlLocateMessageByEuid(uid, &CC->room); - getroom(&CC->room, hold_rm); /* return to saved room */ + CtdlGetRoom(&CC->room, hold_rm); /* return to saved room */ CtdlLogPrintf(CTDL_DEBUG, "msgnum_being_replaced == %ld\n", msgnum_being_replaced); if (msgnum_being_replaced == 0) { @@ -654,7 +655,7 @@ int ical_update_my_calendar_with_reply(icalcomponent *cal) { icalcomponent_free(original_event); /* Don't need this anymore. */ if (serialized_event == NULL) return(2); - MailboxName(roomname, sizeof roomname, &CC->user, USERCALENDARROOM); + CtdlMailboxName(roomname, sizeof roomname, &CC->user, USERCALENDARROOM); message_text = malloc(strlen(serialized_event) + SIZ); if (message_text != NULL) { @@ -807,51 +808,64 @@ int ical_ctdl_is_overlap( struct icaltimetype t2start, struct icaltimetype t2end ) { - if (icaltime_is_null_time(t1start)) return(0); if (icaltime_is_null_time(t2start)) return(0); - /* First, check for all-day events */ - if (t1start.is_date) { - if (!icaltime_compare_date_only(t1start, t2start)) { - return(1); - } - if (!icaltime_is_null_time(t2end)) { - if (!icaltime_compare_date_only(t1start, t2end)) { - return(1); - } + /* if either event lacks end time, assume end = start */ + if (icaltime_is_null_time(t1end)) + memcpy(&t1end, &t1start, sizeof(struct icaltimetype)); + else { + if (t1end.is_date && icaltime_compare(t1start, t1end)) { + /* + * the end date is non-inclusive so adjust it by one + * day because our test is inclusive, note that a day is + * not too much because we are talking about all day + * events + * if start = end we assume that nevertheless the whole + * day is meant + */ + icaltime_adjust(&t1end, -1, 0, 0, 0); } } - if (t2start.is_date) { - if (!icaltime_compare_date_only(t2start, t1start)) { - return(1); - } - if (!icaltime_is_null_time(t1end)) { - if (!icaltime_compare_date_only(t2start, t1end)) { - return(1); - } + if (icaltime_is_null_time(t2end)) + memcpy(&t2end, &t2start, sizeof(struct icaltimetype)); + else { + if (t2end.is_date && icaltime_compare(t2start, t2end)) { + icaltime_adjust(&t2end, -1, 0, 0, 0); } } - /* Now check for overlaps using date *and* time. */ + /* First, check for all-day events */ + if (t1start.is_date || t2start.is_date) { + /* If event 1 ends before event 2 starts, we're in the clear. */ + if (icaltime_compare_date_only(t1end, t2start) < 0) return(0); + + /* If event 2 ends before event 1 starts, we're also ok. */ + if (icaltime_compare_date_only(t2end, t1start) < 0) return(0); + + return(1); + } + + /* lprintf (9, "Comparing t1start %d:%d t1end %d:%d t2start %d:%d t2end %d:%d \n", + t1start.hour, t1start.minute, t1end.hour, t1end.minute, + t2start.hour, t2start.minute, t2end.hour, t2end.minute); + */ - /* First, bail out if either event 1 or event 2 is missing end time. */ - if (icaltime_is_null_time(t1end)) return(0); - if (icaltime_is_null_time(t2end)) return(0); + /* Now check for overlaps using date *and* time. */ /* If event 1 ends before event 2 starts, we're in the clear. */ if (icaltime_compare(t1end, t2start) <= 0) return(0); + /* lprintf(9, "first passed\n"); */ /* If event 2 ends before event 1 starts, we're also ok. */ if (icaltime_compare(t2end, t1start) <= 0) return(0); + /* lprintf(9, "second passed\n"); */ /* Otherwise, they overlap. */ return(1); } - - /* * Phase 6 of "hunt for conflicts" * called by ical_conflicts_phase5() @@ -1158,8 +1172,8 @@ void ical_hunt_for_conflicts(icalcomponent *cal) { strcpy(hold_rm, CC->room.QRname); /* save current room */ - if (getroom(&CC->room, USERCALENDARROOM) != 0) { - getroom(&CC->room, hold_rm); + if (CtdlGetRoom(&CC->room, USERCALENDARROOM) != 0) { + CtdlGetRoom(&CC->room, hold_rm); cprintf("%d You do not have a calendar.\n", ERROR + ROOM_NOT_FOUND); return; } @@ -1174,7 +1188,7 @@ void ical_hunt_for_conflicts(icalcomponent *cal) { ); cprintf("000\n"); - getroom(&CC->room, hold_rm); /* return to saved room */ + CtdlGetRoom(&CC->room, hold_rm); /* return to saved room */ } @@ -1221,23 +1235,30 @@ void ical_conflicts(long msgnum, char *partnum) { /* * Look for busy time in a VEVENT and add it to the supplied VFREEBUSY. + * + * fb The VFREEBUSY component to which we are appending + * top_level_cal The top-level VCALENDAR component which contains a VEVENT to be added */ -void ical_add_to_freebusy(icalcomponent *fb, icalcomponent *cal) { +void ical_add_to_freebusy(icalcomponent *fb, icalcomponent *top_level_cal) { + icalcomponent *cal; icalproperty *p; icalvalue *v; - struct icalperiodtype my_period; + struct icalperiodtype this_event_period = icalperiodtype_null_period(); + icaltimetype dtstart = icaltime_null_time(); + icaltimetype dtend = icaltime_null_time(); - if (cal == NULL) return; - my_period = icalperiodtype_null_period(); + /* recur variables */ + icalproperty *rrule = NULL; + struct icalrecurrencetype recur; + icalrecur_iterator *ritr = NULL; + struct icaldurationtype dur; + int num_recur = 0; - if (icalcomponent_isa(cal) != ICAL_VEVENT_COMPONENT) { - ical_add_to_freebusy(fb, - icalcomponent_get_first_component( - cal, ICAL_VEVENT_COMPONENT - ) - ); - return; - } + if (!top_level_cal) return; + + /* Find the VEVENT component containing an event */ + cal = icalcomponent_get_first_component(top_level_cal, ICAL_VEVENT_COMPONENT); + if (!cal) return; /* If this event is not opaque, the user isn't publishing it as * busy time, so don't bother doing anything else. @@ -1252,58 +1273,100 @@ void ical_add_to_freebusy(icalcomponent *fb, icalcomponent *cal) { } } - /* Convert the DTSTART and DTEND properties to an icalperiod. */ + /* + * Now begin calculating the event start and end times. + */ p = icalcomponent_get_first_property(cal, ICAL_DTSTART_PROPERTY); - if (p != NULL) { - my_period.start = icalproperty_get_dtstart(p); - } - - p = icalcomponent_get_first_property(cal, ICAL_DTEND_PROPERTY); - if (p != NULL) { - my_period.end = icalproperty_get_dtstart(p); - } - - /* Now add it. */ - icalcomponent_add_property(fb, - icalproperty_new_freebusy(my_period) - ); + if (!p) return; + dtstart = icalproperty_get_dtstart(p); - /* Make sure the DTSTART property of the freebusy *list* is set to - * the DTSTART property of the *earliest event*. - */ - p = icalcomponent_get_first_property(fb, ICAL_DTSTART_PROPERTY); - if (p == NULL) { - icalcomponent_set_dtstart(fb, - icalcomponent_get_dtstart(cal) ); + if (icaltime_is_utc(dtstart)) { + dtstart.zone = icaltimezone_get_utc_timezone(); } else { - if (icaltime_compare( - icalcomponent_get_dtstart(cal), - icalcomponent_get_dtstart(fb) - ) < 0) { - icalcomponent_set_dtstart(fb, - icalcomponent_get_dtstart(cal) ); + dtstart.zone = icalcomponent_get_timezone(top_level_cal, + icalparameter_get_tzid( + icalproperty_get_first_parameter(p, ICAL_TZID_PARAMETER) + ) + ); + if (!dtstart.zone) { + dtstart.zone = get_default_icaltimezone(); } } - /* Make sure the DTEND property of the freebusy *list* is set to - * the DTEND property of the *latest event*. - */ - p = icalcomponent_get_first_property(fb, ICAL_DTEND_PROPERTY); - if (p == NULL) { - icalcomponent_set_dtend(fb, - icalcomponent_get_dtend(cal) ); + dtend = icalcomponent_get_dtend(cal); + if (!icaltime_is_null_time(dtend)) { + dur = icaltime_subtract(dtend, dtstart); } - else { - if (icaltime_compare( - icalcomponent_get_dtend(cal), - icalcomponent_get_dtend(fb) - ) > 0) { - icalcomponent_set_dtend(fb, - icalcomponent_get_dtend(cal) ); - } + + /* Is a recurrence specified? If so, get ready to process it... */ + rrule = ical_ctdl_get_subprop(cal, ICAL_RRULE_PROPERTY); + if (rrule) { + recur = icalproperty_get_rrule(rrule); + ritr = icalrecur_iterator_new(recur, dtstart); } + do { + /* Convert the DTSTART and DTEND properties to an icalperiod. */ + this_event_period.start = dtstart; + + if (!icaltime_is_null_time(dtend)) { + this_event_period.end = dtend; + } + + /* Convert the timestamps to UTC. It's ok to do this because we've already expanded + * recurrences and this data is never going to get used again. + */ + this_event_period.start = icaltime_convert_to_zone( + this_event_period.start, + icaltimezone_get_utc_timezone() + ); + this_event_period.end = icaltime_convert_to_zone( + this_event_period.end, + icaltimezone_get_utc_timezone() + ); + + /* Now add it. */ + icalcomponent_add_property(fb, icalproperty_new_freebusy(this_event_period)); + + /* Make sure the DTSTART property of the freebusy *list* is set to + * the DTSTART property of the *earliest event*. + */ + p = icalcomponent_get_first_property(fb, ICAL_DTSTART_PROPERTY); + if (p == NULL) { + icalcomponent_set_dtstart(fb, this_event_period.start); + } + else { + if (icaltime_compare(this_event_period.start, icalcomponent_get_dtstart(fb)) < 0) { + icalcomponent_set_dtstart(fb, this_event_period.start); + } + } + + /* Make sure the DTEND property of the freebusy *list* is set to + * the DTEND property of the *latest event*. + */ + p = icalcomponent_get_first_property(fb, ICAL_DTEND_PROPERTY); + if (p == NULL) { + icalcomponent_set_dtend(fb, this_event_period.end); + } + else { + if (icaltime_compare(this_event_period.end, icalcomponent_get_dtend(fb)) > 0) { + icalcomponent_set_dtend(fb, this_event_period.end); + } + } + + if (rrule) { + dtstart = icalrecur_iterator_next(ritr); + if (!icaltime_is_null_time(dtend)) { + dtend = icaltime_add(dtstart, dur); + dtend.zone = dtstart.zone; + dtend.is_utc = dtstart.is_utc; + } + ++num_recur; + } + + } while ( (rrule) && (!icaltime_is_null_time(dtstart)) && (num_recur < MAX_RECUR) ) ; + icalrecur_iterator_free(ritr); } @@ -1317,11 +1380,11 @@ void ical_add_to_freebusy(icalcomponent *fb, icalcomponent *cal) { * */ void ical_freebusy_backend(long msgnum, void *data) { - icalcomponent *cal; + icalcomponent *fb; struct CtdlMessage *msg = NULL; struct ical_respond_data ird; - cal = (icalcomponent *)data; + fb = (icalcomponent *)data; /* User-supplied data will be the VFREEBUSY component */ msg = CtdlFetchMessage(msgnum, 1); if (msg == NULL) return; @@ -1336,12 +1399,10 @@ void ical_freebusy_backend(long msgnum, void *data) { ); CtdlFreeMessage(msg); - if (ird.cal == NULL) return; - - ical_add_to_freebusy(cal, ird.cal); - - /* Now free the memory. */ - icalcomponent_free(ird.cal); + if (ird.cal) { + ical_add_to_freebusy(fb, ird.cal); /* Add VEVENT times to VFREEBUSY */ + icalcomponent_free(ird.cal); + } } @@ -1365,7 +1426,7 @@ void ical_freebusy(char *who) { int config_lines = 0; /* First try an exact match. */ - found_user = getuser(&usbuf, who); + found_user = CtdlGetUser(&usbuf, who); /* If not found, try it as an unqualified email address. */ if (found_user != 0) { @@ -1374,7 +1435,7 @@ void ical_freebusy(char *who) { CtdlLogPrintf(CTDL_DEBUG, "Trying <%s>\n", buf); if (recp != NULL) { if (recp->num_local == 1) { - found_user = getuser(&usbuf, recp->recp_local); + found_user = CtdlGetUser(&usbuf, recp->recp_local); } free_recipients(recp); } @@ -1389,7 +1450,7 @@ void ical_freebusy(char *who) { recp = validate_recipients(buf, NULL, 0); if (recp != NULL) { if (recp->num_local == 1) { - found_user = getuser(&usbuf, recp->recp_local); + found_user = CtdlGetUser(&usbuf, recp->recp_local); } free_recipients(recp); } @@ -1412,7 +1473,7 @@ void ical_freebusy(char *who) { recp = validate_recipients(buf, NULL, 0); if (recp != NULL) { if (recp->num_local == 1) { - found_user = getuser(&usbuf, recp->recp_local); + found_user = CtdlGetUser(&usbuf, recp->recp_local); } free_recipients(recp); } @@ -1425,14 +1486,14 @@ void ical_freebusy(char *who) { return; } - MailboxName(calendar_room_name, sizeof calendar_room_name, + CtdlMailboxName(calendar_room_name, sizeof calendar_room_name, &usbuf, USERCALENDARROOM); strcpy(hold_rm, CC->room.QRname); /* save current room */ - if (getroom(&CC->room, calendar_room_name) != 0) { + if (CtdlGetRoom(&CC->room, calendar_room_name) != 0) { cprintf("%d Cannot open calendar\n", ERROR + ROOM_NOT_FOUND); - getroom(&CC->room, hold_rm); + CtdlGetRoom(&CC->room, hold_rm); return; } @@ -1442,7 +1503,7 @@ void ical_freebusy(char *who) { if (fb == NULL) { cprintf("%d Internal error: cannot allocate memory.\n", ERROR + INTERNAL_ERROR); - getroom(&CC->room, hold_rm); + CtdlGetRoom(&CC->room, hold_rm); return; } @@ -1484,7 +1545,7 @@ void ical_freebusy(char *who) { icalcomponent_free(fb); cprintf("%d Internal error: cannot allocate memory.\n", ERROR + INTERNAL_ERROR); - getroom(&CC->room, hold_rm); + CtdlGetRoom(&CC->room, hold_rm); return; } @@ -1497,7 +1558,7 @@ void ical_freebusy(char *who) { serialized_request = icalcomponent_as_ical_string_r(encaps); icalcomponent_free(encaps); /* Don't need this anymore. */ - cprintf("%d Here is the free/busy data:\n", LISTING_FOLLOWS); + cprintf("%d Free/busy for %s\n", LISTING_FOLLOWS, usbuf.fullname); if (serialized_request != NULL) { client_write(serialized_request, strlen(serialized_request)); free(serialized_request); @@ -1505,7 +1566,7 @@ void ical_freebusy(char *who) { cprintf("\n000\n"); /* Go back to the room from which we came... */ - getroom(&CC->room, hold_rm); + CtdlGetRoom(&CC->room, hold_rm); } @@ -1602,7 +1663,7 @@ void ical_getics(void) encaps = icalcomponent_new_vcalendar(); if (encaps == NULL) { - CtdlLogPrintf(CTDL_DEBUG, "ERROR: could not allocate component!\n"); + CtdlLogPrintf(CTDL_ALERT, "ERROR: could not allocate component!\n"); cprintf("%d Could not allocate memory\n", ERROR+INTERNAL_ERROR); return; } @@ -1645,7 +1706,7 @@ void ical_putics_grabtzids(icalparameter *param, void *data) HashList *keys = (HashList *) data; if ( (keys) && (tzid) && (!IsEmptyStr(tzid)) ) { - Put(keys, tzid, strlen(tzid), strdup(tzid), generic_free_handler); + Put(keys, tzid, strlen(tzid), strdup(tzid), NULL); } } @@ -1680,7 +1741,7 @@ void ical_putics(void) } cprintf("%d Transmit data now\n", SEND_LISTING); - calstream = CtdlReadMessageBody("000", config.c_maxmsglen, NULL, 0, 0); + calstream = CtdlReadMessageBody(HKEY("000"), config.c_maxmsglen, NULL, 0, 0); if (calstream == NULL) { return; } @@ -1843,22 +1904,22 @@ void cmd_ical(char *argbuf) /* * We don't know if the calendar room exists so we just create it at login */ -void ical_create_room(void) +void ical_CtdlCreateRoom(void) { struct ctdlroom qr; - struct visit vbuf; + visit vbuf; /* Create the calendar room if it doesn't already exist */ - create_room(USERCALENDARROOM, 4, "", 0, 1, 0, VIEW_CALENDAR); + CtdlCreateRoom(USERCALENDARROOM, 4, "", 0, 1, 0, VIEW_CALENDAR); /* Set expiration policy to manual; otherwise objects will be lost! */ - if (lgetroom(&qr, USERCALENDARROOM)) { + if (CtdlGetRoomLock(&qr, USERCALENDARROOM)) { CtdlLogPrintf(CTDL_CRIT, "Couldn't get the user calendar room!\n"); return; } qr.QRep.expire_mode = EXPIRE_MANUAL; qr.QRdefaultview = VIEW_CALENDAR; /* 3 = calendar view */ - lputroom(&qr); + CtdlPutRoomLock(&qr); /* Set the view to a calendar view */ CtdlGetRelationship(&vbuf, &CC->user, &qr); @@ -1866,16 +1927,16 @@ void ical_create_room(void) CtdlSetRelationship(&vbuf, &CC->user, &qr); /* Create the tasks list room if it doesn't already exist */ - create_room(USERTASKSROOM, 4, "", 0, 1, 0, VIEW_TASKS); + CtdlCreateRoom(USERTASKSROOM, 4, "", 0, 1, 0, VIEW_TASKS); /* Set expiration policy to manual; otherwise objects will be lost! */ - if (lgetroom(&qr, USERTASKSROOM)) { + if (CtdlGetRoomLock(&qr, USERTASKSROOM)) { CtdlLogPrintf(CTDL_CRIT, "Couldn't get the user calendar room!\n"); return; } qr.QRep.expire_mode = EXPIRE_MANUAL; qr.QRdefaultview = VIEW_TASKS; - lputroom(&qr); + CtdlPutRoomLock(&qr); /* Set the view to a task list view */ CtdlGetRelationship(&vbuf, &CC->user, &qr); @@ -1883,16 +1944,16 @@ void ical_create_room(void) CtdlSetRelationship(&vbuf, &CC->user, &qr); /* Create the notes room if it doesn't already exist */ - create_room(USERNOTESROOM, 4, "", 0, 1, 0, VIEW_NOTES); + CtdlCreateRoom(USERNOTESROOM, 4, "", 0, 1, 0, VIEW_NOTES); /* Set expiration policy to manual; otherwise objects will be lost! */ - if (lgetroom(&qr, USERNOTESROOM)) { + if (CtdlGetRoomLock(&qr, USERNOTESROOM)) { CtdlLogPrintf(CTDL_CRIT, "Couldn't get the user calendar room!\n"); return; } qr.QRep.expire_mode = EXPIRE_MANUAL; qr.QRdefaultview = VIEW_NOTES; - lputroom(&qr); + CtdlPutRoomLock(&qr); /* Set the view to a notes view */ CtdlGetRelationship(&vbuf, &CC->user, &qr); @@ -1927,11 +1988,13 @@ void ical_send_out_invitations(icalcomponent *top_level_cal, icalcomponent *cal) size_t reqsize; icalproperty *p; struct icaltimetype t; - icaltimezone *attached_zones[5] = { NULL, NULL, NULL, NULL, NULL }; + const icaltimezone *attached_zones[5] = { NULL, NULL, NULL, NULL, NULL }; int i; - icaltimezone *z; + const icaltimezone *z; int num_zones_attached = 0; int zone_already_attached; + icalparameter *tzidp = NULL; + const char *tzidc = NULL; if (cal == NULL) { CtdlLogPrintf(CTDL_ERR, "ERROR: trying to reply to NULL event?\n"); @@ -2001,7 +2064,7 @@ void ical_send_out_invitations(icalcomponent *top_level_cal, icalcomponent *cal) /* Encapsulate the VEVENT component into a complete VCALENDAR */ encaps = icalcomponent_new_vcalendar(); if (encaps == NULL) { - CtdlLogPrintf(CTDL_DEBUG, "ERROR: could not allocate component!\n"); + CtdlLogPrintf(CTDL_ALERT, "ERROR: could not allocate component!\n"); icalcomponent_free(the_request); return; } @@ -2035,9 +2098,15 @@ void ical_send_out_invitations(icalcomponent *top_level_cal, icalcomponent *cal) || (icalproperty_isa(p) == ICAL_RECURRENCEID_PROPERTY) ) { t = icalproperty_get_dtstart(p); // it's safe to use dtstart for all of them - CtdlLogPrintf(CTDL_DEBUG, "Found an icaltimetype: %s\n", - icaltime_as_ical_string(t) - ); + + /* Determine the tzid in order for some of the conditions below to work */ + tzidp = icalproperty_get_first_parameter(p, ICAL_TZID_PARAMETER); + if (tzidp) { + tzidc = icalparameter_get_tzid(tzidp); + } + else { + tzidc = NULL; + } /* First see if there's a timezone attached to the data structure itself */ if (icaltime_is_utc(t)) { @@ -2046,40 +2115,29 @@ void ical_send_out_invitations(icalcomponent *top_level_cal, icalcomponent *cal) else { z = icaltime_get_timezone(t); } - if (z) CtdlLogPrintf(CTDL_DEBUG, "Timezone is present in data structure\n"); /* If not, try to determine the tzid from the parameter using attached zones */ - if (!z) { - z = icalcomponent_get_timezone(top_level_cal, - icalparameter_get_tzid( - icalproperty_get_first_parameter(p, ICAL_TZID_PARAMETER) - ) - ); - if (z) CtdlLogPrintf(CTDL_DEBUG, "Timezone was found in attached zones\n"); + if ((!z) && (tzidc)) { + z = icalcomponent_get_timezone(top_level_cal, tzidc); } /* Still no good? Try our internal database */ - if (!z) { - z = icaltimezone_get_builtin_timezone_from_tzid( - icalparameter_get_tzid( - icalproperty_get_first_parameter(p, ICAL_TZID_PARAMETER) - ) - ); - if (z) CtdlLogPrintf(CTDL_DEBUG, "Timezone was found in internal db\n"); + if ((!z) && (tzidc)) { + z = icaltimezone_get_builtin_timezone_from_tzid(tzidc); } if (z) { - CtdlLogPrintf(CTDL_DEBUG, "Have valid timezone, need to attach it.\n"); + /* We have a valid timezone. Good. Now we need to attach it. */ zone_already_attached = 0; for (i=0; i<5; ++i) { if (z == attached_zones[i]) { + /* We've already got this one, no need to attach another. */ ++zone_already_attached; - CtdlLogPrintf(CTDL_DEBUG, "zone already attached!!\n"); } } if ((!zone_already_attached) && (num_zones_attached < 5)) { - CtdlLogPrintf(CTDL_DEBUG, "attach zone %d\n", num_zones_attached); + /* This is a new one, so attach it. */ attached_zones[num_zones_attached++] = z; } @@ -2108,8 +2166,6 @@ void ical_send_out_invitations(icalcomponent *top_level_cal, icalcomponent *cal) icalcomponent_free(encaps); /* Don't need this anymore. */ if (serialized_request == NULL) return; - CtdlLogPrintf(CTDL_DEBUG, "SENDING INVITATIONS:\n%s\n", serialized_request); - reqsize = strlen(serialized_request) + SIZ; request_message_text = malloc(reqsize); if (request_message_text != NULL) { @@ -2118,16 +2174,20 @@ void ical_send_out_invitations(icalcomponent *top_level_cal, icalcomponent *cal) serialized_request ); - msg = CtdlMakeMessage(&CC->user, - "", /* No single recipient here */ - "", /* No single recipient here */ - CC->room.QRname, 0, FMT_RFC822, - "", - "", + msg = CtdlMakeMessage( + &CC->user, + NULL, /* No single recipient here */ + NULL, /* No single recipient here */ + CC->room.QRname, + 0, + FMT_RFC822, + NULL, + NULL, summary_string, /* Use summary for subject */ NULL, request_message_text, - NULL); + NULL + ); if (msg != NULL) { valid = validate_recipients(attendees_string, NULL, 0); @@ -2398,7 +2458,7 @@ int ical_obj_aftersave(struct CtdlMessage *msg) */ /* First determine if this is our room */ - MailboxName(roomname, sizeof roomname, &CC->user, USERCALENDARROOM); + CtdlMailboxName(roomname, sizeof roomname, &CC->user, USERCALENDARROOM); if (strcasecmp(roomname, CC->room.QRname)) { return(0); /* Not the Calendar room -- don't do anything. */ } @@ -2529,7 +2589,7 @@ CTDL_MODULE_INIT(calendar) /* Initialize our hook functions */ CtdlRegisterMessageHook(ical_obj_beforesave, EVT_BEFORESAVE); CtdlRegisterMessageHook(ical_obj_aftersave, EVT_AFTERSAVE); - CtdlRegisterSessionHook(ical_create_room, EVT_LOGIN); + CtdlRegisterSessionHook(ical_CtdlCreateRoom, EVT_LOGIN); CtdlRegisterProtoHook(cmd_ical, "ICAL", "Citadel iCal commands"); CtdlRegisterSessionHook(ical_session_startup, EVT_START); CtdlRegisterSessionHook(ical_session_shutdown, EVT_STOP);