citadel/modules/calendar/serv_calendar.c

   1 /*
   2  * This module implements iCalendar object processing and the Calendar>
   3  * room on a Citadel server.  It handles iCalendar objects using the
   4  * iTIP protocol.  See RFCs 2445 and 2446.
   5  *
   6  *
   7  * Copyright (c) 1987-2011 by the citadel.org team
   8  *
   9  *  This program is open source software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 3 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  */
  23
  24 #define PRODID "-//Citadel//NONSGML Citadel Calendar//EN"
  25
  26 #include "ctdl_module.h"
  27
  28 #include <libical/ical.h>
  29
  30 #include "msgbase.h"
  31 #include "internet_addressing.h"
  32 #include "serv_calendar.h"
  33 #include "euidindex.h"
  34 #include "ical_dezonify.h"
  35
  36
  37
  38 struct ical_respond_data {
  39         char desired_partnum[SIZ];
  40         icalcomponent *cal;
  41 };
  42
  43
  44 /*
  45  * Utility function to create a new VCALENDAR component with some of the
  46  * required fields already set the way we like them.
  47  */
  48 icalcomponent *icalcomponent_new_citadel_vcalendar(void) {
  49         icalcomponent *encaps;
  50
  51         encaps = icalcomponent_new_vcalendar();
  52         if (encaps == NULL) {
  53                 syslog(LOG_CRIT, "ERROR: could not allocate component!\n");
  54                 return NULL;
  55         }
  56
  57         /* Set the Product ID */
  58         icalcomponent_add_property(encaps, icalproperty_new_prodid(PRODID));
  59
  60         /* Set the Version Number */
  61         icalcomponent_add_property(encaps, icalproperty_new_version("2.0"));
  62
  63         return(encaps);
  64 }
  65
  66
  67 /*
  68  * Utility function to encapsulate a subcomponent into a full VCALENDAR
  69  */
  70 icalcomponent *ical_encapsulate_subcomponent(icalcomponent *subcomp) {
  71         icalcomponent *encaps;
  72
  73         /* If we're already looking at a full VCALENDAR component,
  74          * don't bother ... just return itself.
  75          */
  76         if (icalcomponent_isa(subcomp) == ICAL_VCALENDAR_COMPONENT) {
  77                 return subcomp;
  78         }
  79
  80         /* Encapsulate the VEVENT component into a complete VCALENDAR */
  81         encaps = icalcomponent_new_citadel_vcalendar();
  82         if (encaps == NULL) return NULL;
  83
  84         /* Encapsulate the subcomponent inside */
  85         icalcomponent_add_component(encaps, subcomp);
  86
  87         /* Return the object we just created. */
  88         return(encaps);
  89 }
  90
  91
  92
  93
  94 /*
  95  * Write a calendar object into the specified user's calendar room.
  96  * If the supplied user is NULL, this function writes the calendar object
  97  * to the currently selected room.
  98  */
  99 void ical_write_to_cal(struct ctdluser *u, icalcomponent *cal) {
 100         char *ser = NULL;
 101         long serlen;
 102         icalcomponent *encaps = NULL;
 103         struct CtdlMessage *msg = NULL;
 104         icalcomponent *tmp=NULL;
 105
 106         if (cal == NULL) return;
 107
 108         /* If the supplied object is a subcomponent, encapsulate it in
 109          * a full VCALENDAR component, and save that instead.
 110          */
 111         if (icalcomponent_isa(cal) != ICAL_VCALENDAR_COMPONENT) {
 112                 tmp = icalcomponent_new_clone(cal);
 113                 encaps = ical_encapsulate_subcomponent(tmp);
 114                 ical_write_to_cal(u, encaps);
 115                 icalcomponent_free(tmp);
 116                 icalcomponent_free(encaps);
 117                 return;
 118         }
 119
 120         ser = icalcomponent_as_ical_string_r(cal);
 121         if (ser == NULL) return;
 122
 123         serlen = strlen(ser);
 124
 125         /* If the caller supplied a user, write to that user's default calendar room */
 126         if (u) {
 127                 /* This handy API function does all the work for us. */
 128                 CtdlWriteObject(USERCALENDARROOM,       /* which room */
 129                         "text/calendar",        /* MIME type */
 130                         ser,                    /* data */
 131                         serlen + 1,             /* length */
 132                         u,                      /* which user */
 133                         0,                      /* not binary */
 134                         0,                      /* don't delete others of this type */
 135                         0                       /* no flags */
 136                 );
 137         }
 138
 139         /* If the caller did not supply a user, write to the currently selected room */
 140         if (!u) {
 141                 struct CitContext *CCC = CC;
 142                 StrBuf *MsgBody;
 143
 144                 msg = malloc(sizeof(struct CtdlMessage));
 145                 memset(msg, 0, sizeof(struct CtdlMessage));
 146                 msg->cm_magic = CTDLMESSAGE_MAGIC;
 147                 msg->cm_anon_type = MES_NORMAL;
 148                 msg->cm_format_type = 4;
 149                 CM_SetField(msg, eAuthor, CCC->user.fullname, strlen(CCC->user.fullname));
 150                 CM_SetField(msg, eOriginalRoom, CCC->room.QRname, strlen(CCC->room.QRname));
 151                 CM_SetField(msg, eNodeName, config.c_nodename, strlen(config.c_nodename));
 152                 CM_SetField(msg, eHumanNode, config.c_humannode, strlen(config.c_humannode));
 153
 154                 MsgBody = NewStrBufPlain(NULL, serlen + 100);
 155                 StrBufAppendBufPlain(MsgBody, HKEY("Content-type: text/calendar\r\n\r\n"), 0);
 156                 StrBufAppendBufPlain(MsgBody, ser, serlen, 0);
 157
 158                 CM_SetAsFieldSB(msg, eMesageText, &MsgBody);
 159
 160                 /* Now write the data */
 161                 CtdlSubmitMsg(msg, NULL, "", QP_EADDR);
 162                 CtdlFreeMessage(msg);
 163         }
 164
 165         /* In either case, now we can free the serialized calendar object */
 166         free(ser);
 167 }
 168
 169
 170 /*
 171  * Send a reply to a meeting invitation.
 172  *
 173  * 'request' is the invitation to reply to.
 174  * 'action' is the string "accept" or "decline" or "tentative".
 175  *
 176  */
 177 void ical_send_a_reply(icalcomponent *request, char *action) {
 178         icalcomponent *the_reply = NULL;
 179         icalcomponent *vevent = NULL;
 180         icalproperty *attendee = NULL;
 181         char attendee_string[SIZ];
 182         icalproperty *organizer = NULL;
 183         char organizer_string[SIZ];
 184         icalproperty *summary = NULL;
 185         char summary_string[SIZ];
 186         icalproperty *me_attend = NULL;
 187         struct recptypes *recp = NULL;
 188         icalparameter *partstat = NULL;
 189         char *serialized_reply = NULL;
 190         char *reply_message_text = NULL;
 191         const char *ch;
 192         struct CtdlMessage *msg = NULL;
 193         struct recptypes *valid = NULL;
 194
 195         *organizer_string = '\0';
 196         strcpy(summary_string, "Calendar item");
 197
 198         if (request == NULL) {
 199                 syslog(LOG_ERR, "ERROR: trying to reply to NULL event?\n");
 200                 return;
 201         }
 202
 203         the_reply = icalcomponent_new_clone(request);
 204         if (the_reply == NULL) {
 205                 syslog(LOG_ERR, "ERROR: cannot clone request\n");
 206                 return;
 207         }
 208
 209         /* Change the method from REQUEST to REPLY */
 210         icalcomponent_set_method(the_reply, ICAL_METHOD_REPLY);
 211
 212         vevent = icalcomponent_get_first_component(the_reply, ICAL_VEVENT_COMPONENT);
 213         if (vevent != NULL) {
 214                 /* Hunt for attendees, removing ones that aren't us.
 215                  * (Actually, remove them all, cloning our own one so we can
 216                  * re-insert it later)
 217                  */
 218                 while (attendee = icalcomponent_get_first_property(vevent,
 219                     ICAL_ATTENDEE_PROPERTY), (attendee != NULL)
 220                 ) {
 221                         ch = icalproperty_get_attendee(attendee);
 222                         if ((ch != NULL) && !strncasecmp(ch, "MAILTO:", 7)) {
 223                                 safestrncpy(attendee_string, ch + 7, sizeof (attendee_string));
 224                                 striplt(attendee_string);
 225                                 recp = validate_recipients(attendee_string, NULL, 0);
 226                                 if (recp != NULL) {
 227                                         if (!strcasecmp(recp->recp_local, CC->user.fullname)) {
 228                                                 if (me_attend) icalproperty_free(me_attend);
 229                                                 me_attend = icalproperty_new_clone(attendee);
 230                                         }
 231                                         free_recipients(recp);
 232                                 }
 233                         }
 234
 235                         /* Remove it... */
 236                         icalcomponent_remove_property(vevent, attendee);
 237                         icalproperty_free(attendee);
 238                 }
 239
 240                 /* We found our own address in the attendee list. */
 241                 if (me_attend) {
 242                         /* Change the partstat from NEEDS-ACTION to ACCEPT or DECLINE */
 243                         icalproperty_remove_parameter(me_attend, ICAL_PARTSTAT_PARAMETER);
 244
 245                         if (!strcasecmp(action, "accept")) {
 246                                 partstat = icalparameter_new_partstat(ICAL_PARTSTAT_ACCEPTED);
 247                         }
 248                         else if (!strcasecmp(action, "decline")) {
 249                                 partstat = icalparameter_new_partstat(ICAL_PARTSTAT_DECLINED);
 250                         }
 251                         else if (!strcasecmp(action, "tentative")) {
 252                                 partstat = icalparameter_new_partstat(ICAL_PARTSTAT_TENTATIVE);
 253                         }
 254
 255                         if (partstat) icalproperty_add_parameter(me_attend, partstat);
 256
 257                         /* Now insert it back into the vevent. */
 258                         icalcomponent_add_property(vevent, me_attend);
 259                 }
 260
 261                 /* Figure out who to send this thing to */
 262                 organizer = icalcomponent_get_first_property(vevent, ICAL_ORGANIZER_PROPERTY);
 263                 if (organizer != NULL) {
 264                         if (icalproperty_get_organizer(organizer)) {
 265                                 strcpy(organizer_string,
 266                                         icalproperty_get_organizer(organizer) );
 267                         }
 268                 }
 269                 if (!strncasecmp(organizer_string, "MAILTO:", 7)) {
 270                         strcpy(organizer_string, &organizer_string[7]);
 271                         striplt(organizer_string);
 272                 } else {
 273                         strcpy(organizer_string, "");
 274                 }
 275
 276                 /* Extract the summary string -- we'll use it as the
 277                  * message subject for the reply
 278                  */
 279                 summary = icalcomponent_get_first_property(vevent, ICAL_SUMMARY_PROPERTY);
 280                 if (summary != NULL) {
 281                         if (icalproperty_get_summary(summary)) {
 282                                 strcpy(summary_string,
 283                                         icalproperty_get_summary(summary) );
 284                         }
 285                 }
 286         }
 287
 288         /* Now generate the reply message and send it out. */
 289         serialized_reply = icalcomponent_as_ical_string_r(the_reply);
 290         icalcomponent_free(the_reply);  /* don't need this anymore */
 291         if (serialized_reply == NULL) return;
 292
 293         reply_message_text = malloc(strlen(serialized_reply) + SIZ);
 294         if (reply_message_text != NULL) {
 295                 sprintf(reply_message_text,
 296                         "Content-type: text/calendar; charset=\"utf-8\"\r\n\r\n%s\r\n",
 297                         serialized_reply
 298                 );
 299
 300                 msg = CtdlMakeMessage(&CC->user,
 301                         organizer_string,       /* to */
 302                         "",                     /* cc */
 303                         CC->room.QRname, 0, FMT_RFC822,
 304                         "",
 305                         "",
 306                         summary_string,         /* Use summary for subject */
 307                         NULL,
 308                         reply_message_text,
 309                         NULL);
 310
 311                 if (msg != NULL) {
 312                         valid = validate_recipients(organizer_string, NULL, 0);
 313                         CtdlSubmitMsg(msg, valid, "", QP_EADDR);
 314                         CtdlFreeMessage(msg);
 315                         free_recipients(valid);
 316                 }
 317         }
 318         free(serialized_reply);
 319 }
 320
 321
 322
 323 /*
 324  * Callback function for mime parser that hunts for calendar content types
 325  * and turns them into calendar objects.  If something is found, it is placed
 326  * in ird->cal, and the caller now owns that memory and is responsible for freeing it.
 327  */
 328 void ical_locate_part(char *name, char *filename, char *partnum, char *disp,
 329                 void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
 330                 char *cbid, void *cbuserdata) {
 331
 332         struct ical_respond_data *ird = NULL;
 333
 334         ird = (struct ical_respond_data *) cbuserdata;
 335
 336         /* desired_partnum can be set to "_HUNT_" to have it just look for
 337          * the first part with a content type of text/calendar.  Otherwise
 338          * we have to only process the right one.
 339          */
 340         if (strcasecmp(ird->desired_partnum, "_HUNT_")) {
 341                 if (strcasecmp(partnum, ird->desired_partnum)) {
 342                         return;
 343                 }
 344         }
 345
 346         if (  (strcasecmp(cbtype, "text/calendar"))
 347            && (strcasecmp(cbtype, "application/ics")) ) {
 348                 return;
 349         }
 350
 351         if (ird->cal != NULL) {
 352                 icalcomponent_free(ird->cal);
 353                 ird->cal = NULL;
 354         }
 355
 356         ird->cal = icalcomponent_new_from_string(content);
 357 }
 358
 359
 360 /*
 361  * Respond to a meeting request.
 362  */
 363 void ical_respond(long msgnum, char *partnum, char *action) {
 364         struct CtdlMessage *msg = NULL;
 365         struct ical_respond_data ird;
 366
 367         if (
 368            (strcasecmp(action, "accept"))
 369            && (strcasecmp(action, "decline"))
 370         ) {
 371                 cprintf("%d Action must be 'accept' or 'decline'\n",
 372                         ERROR + ILLEGAL_VALUE
 373                 );
 374                 return;
 375         }
 376
 377         msg = CtdlFetchMessage(msgnum, 1);
 378         if (msg == NULL) {
 379                 cprintf("%d Message %ld not found.\n",
 380                         ERROR + ILLEGAL_VALUE,
 381                         (long)msgnum
 382                 );
 383                 return;
 384         }
 385
 386         memset(&ird, 0, sizeof ird);
 387         strcpy(ird.desired_partnum, partnum);
 388         mime_parser(msg->cm_fields[eMesageText],
 389                 NULL,
 390                 *ical_locate_part,              /* callback function */
 391                 NULL, NULL,
 392                 (void *) &ird,                  /* user data */
 393                 0
 394         );
 395
 396         /* We're done with the incoming message, because we now have a
 397          * calendar object in memory.
 398          */
 399         CtdlFreeMessage(msg);
 400
 401         /*
 402          * Here is the real meat of this function.  Handle the event.
 403          */
 404         if (ird.cal != NULL) {
 405                 /* Save this in the user's calendar if necessary */
 406                 if (!strcasecmp(action, "accept")) {
 407                         ical_write_to_cal(&CC->user, ird.cal);
 408                 }
 409
 410                 /* Send a reply if necessary */
 411                 if (icalcomponent_get_method(ird.cal) == ICAL_METHOD_REQUEST) {
 412                         ical_send_a_reply(ird.cal, action);
 413                 }
 414
 415                 /* We used to delete the invitation after handling it.
 416                  * We don't do that anymore, but here is the code that handled it:
 417                  * CtdlDeleteMessages(CC->room.QRname, &msgnum, 1, "");
 418                  */
 419
 420                 /* Free the memory we allocated and return a response. */
 421                 icalcomponent_free(ird.cal);
 422                 ird.cal = NULL;
 423                 cprintf("%d ok\n", CIT_OK);
 424                 return;
 425         }
 426         else {
 427                 cprintf("%d No calendar object found\n", ERROR + ROOM_NOT_FOUND);
 428                 return;
 429         }
 430
 431         /* should never get here */
 432 }
 433
 434
 435 /*
 436  * Figure out the UID of the calendar event being referred to in a
 437  * REPLY object.  This function is recursive.
 438  */
 439 void ical_learn_uid_of_reply(char *uidbuf, icalcomponent *cal) {
 440         icalcomponent *subcomponent;
 441         icalproperty *p;
 442
 443         /* If this object is a REPLY, then extract the UID. */
 444         if (icalcomponent_isa(cal) == ICAL_VEVENT_COMPONENT) {
 445                 p = icalcomponent_get_first_property(cal, ICAL_UID_PROPERTY);
 446                 if (p != NULL) {
 447                         strcpy(uidbuf, icalproperty_get_comment(p));
 448                 }
 449         }
 450
 451         /* Otherwise, recurse through any VEVENT subcomponents.  We do NOT want the
 452          * UID of the reply; we want the UID of the invitation being replied to.
 453          */
 454         for (subcomponent = icalcomponent_get_first_component(cal, ICAL_VEVENT_COMPONENT);
 455             subcomponent != NULL;
 456             subcomponent = icalcomponent_get_next_component(cal, ICAL_VEVENT_COMPONENT) ) {
 457                 ical_learn_uid_of_reply(uidbuf, subcomponent);
 458         }
 459 }
 460
 461
 462 /*
 463  * ical_update_my_calendar_with_reply() refers to this callback function; when we
 464  * locate the message containing the calendar event we're replying to, this function
 465  * gets called.  It basically just sticks the message number in a supplied buffer.
 466  */
 467 void ical_hunt_for_event_to_update(long msgnum, void *data) {
 468         long *msgnumptr;
 469
 470         msgnumptr = (long *) data;
 471         *msgnumptr = msgnum;
 472 }
 473
 474
 475 struct original_event_container {
 476         icalcomponent *c;
 477 };
 478
 479 /*
 480  * Callback function for mime parser that hunts for calendar content types
 481  * and turns them into calendar objects (called by ical_update_my_calendar_with_reply()
 482  * to fetch the object being updated)
 483  */
 484 void ical_locate_original_event(char *name, char *filename, char *partnum, char *disp,
 485                 void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
 486                 char *cbid, void *cbuserdata) {
 487
 488         struct original_event_container *oec = NULL;
 489
 490         if (  (strcasecmp(cbtype, "text/calendar"))
 491            && (strcasecmp(cbtype, "application/ics")) ) {
 492                 return;
 493         }
 494         oec = (struct original_event_container *) cbuserdata;
 495         if (oec->c != NULL) {
 496                 icalcomponent_free(oec->c);
 497         }
 498         oec->c = icalcomponent_new_from_string(content);
 499 }
 500
 501
 502 /*
 503  * Merge updated attendee information from a REPLY into an existing event.
 504  */
 505 void ical_merge_attendee_reply(icalcomponent *event, icalcomponent *reply) {
 506         icalcomponent *c;
 507         icalproperty *e_attendee, *r_attendee;
 508
 509         /* First things first.  If we're not looking at a VEVENT component,
 510          * recurse through subcomponents until we find one.
 511          */
 512         if (icalcomponent_isa(event) != ICAL_VEVENT_COMPONENT) {
 513                 for (c = icalcomponent_get_first_component(event, ICAL_VEVENT_COMPONENT);
 514                     c != NULL;
 515                     c = icalcomponent_get_next_component(event, ICAL_VEVENT_COMPONENT) ) {
 516                         ical_merge_attendee_reply(c, reply);
 517                 }
 518                 return;
 519         }
 520
 521         /* Now do the same thing with the reply.
 522          */
 523         if (icalcomponent_isa(reply) != ICAL_VEVENT_COMPONENT) {
 524                 for (c = icalcomponent_get_first_component(reply, ICAL_VEVENT_COMPONENT);
 525                     c != NULL;
 526                     c = icalcomponent_get_next_component(reply, ICAL_VEVENT_COMPONENT) ) {
 527                         ical_merge_attendee_reply(event, c);
 528                 }
 529                 return;
 530         }
 531
 532         /* Clone the reply, because we're going to rip its guts out. */
 533         reply = icalcomponent_new_clone(reply);
 534
 535         /* At this point we're looking at the correct subcomponents.
 536          * Iterate through the attendees looking for a match.
 537          */
 538 STARTOVER:
 539         for (e_attendee = icalcomponent_get_first_property(event, ICAL_ATTENDEE_PROPERTY);
 540             e_attendee != NULL;
 541             e_attendee = icalcomponent_get_next_property(event, ICAL_ATTENDEE_PROPERTY)) {
 542
 543                 for (r_attendee = icalcomponent_get_first_property(reply, ICAL_ATTENDEE_PROPERTY);
 544                     r_attendee != NULL;
 545                     r_attendee = icalcomponent_get_next_property(reply, ICAL_ATTENDEE_PROPERTY)) {
 546
 547                         /* Check to see if these two attendees match...
 548                          */
 549                         const char *e, *r;
 550                         e = icalproperty_get_attendee(e_attendee);
 551                         r = icalproperty_get_attendee(r_attendee);
 552
 553                         if ((e != NULL) &&
 554                             (r != NULL) &&
 555                             !strcasecmp(e, r)) {
 556                                 /* ...and if they do, remove the attendee from the event
 557                                  * and replace it with the attendee from the reply.  (The
 558                                  * reply's copy will have the same address, but an updated
 559                                  * status.)
 560                                  */
 561                                 icalcomponent_remove_property(event, e_attendee);
 562                                 icalproperty_free(e_attendee);
 563                                 icalcomponent_remove_property(reply, r_attendee);
 564                                 icalcomponent_add_property(event, r_attendee);
 565
 566                                 /* Since we diddled both sets of attendees, we have to start
 567                                  * the iteration over again.  This will not create an infinite
 568                                  * loop because we removed the attendee from the reply.  (That's
 569                                  * why we cloned the reply, and that's what we mean by "ripping
 570                                  * its guts out.")
 571                                  */
 572                                 goto STARTOVER;
 573                         }
 574
 575                 }
 576         }
 577
 578         /* Free the *clone* of the reply. */
 579         icalcomponent_free(reply);
 580 }
 581
 582
 583
 584
 585 /*
 586  * Handle an incoming RSVP (object with method==ICAL_METHOD_REPLY) for a
 587  * calendar event.  The object has already been deserialized for us; all
 588  * we have to do here is hunt for the event in our calendar, merge in the
 589  * updated attendee status, and save it again.
 590  *
 591  * This function returns 0 on success, 1 if the event was not found in the
 592  * user's calendar, or 2 if an internal error occurred.
 593  */
 594 int ical_update_my_calendar_with_reply(icalcomponent *cal) {
 595         char uid[SIZ];
 596         char hold_rm[ROOMNAMELEN];
 597         long msgnum_being_replaced = 0;
 598         struct CtdlMessage *msg = NULL;
 599         struct original_event_container oec;
 600         icalcomponent *original_event;
 601         char *serialized_event = NULL;
 602         char roomname[ROOMNAMELEN];
 603         char *message_text = NULL;
 604
 605         /* Figure out just what event it is we're dealing with */
 606         strcpy(uid, "--==<< InVaLiD uId >>==--");
 607         ical_learn_uid_of_reply(uid, cal);
 608         syslog(LOG_DEBUG, "UID of event being replied to is <%s>\n", uid);
 609
 610         strcpy(hold_rm, CC->room.QRname);       /* save current room */
 611
 612         if (CtdlGetRoom(&CC->room, USERCALENDARROOM) != 0) {
 613                 CtdlGetRoom(&CC->room, hold_rm);
 614                 syslog(LOG_CRIT, "cannot get user calendar room\n");
 615                 return(2);
 616         }
 617
 618         /*
 619          * Look in the EUID index for a message with
 620          * the Citadel EUID set to the value we're looking for.  Since
 621          * Citadel always sets the message EUID to the iCalendar UID of
 622          * the event, this will work.
 623          */
 624         msgnum_being_replaced = CtdlLocateMessageByEuid(uid, &CC->room);
 625
 626         CtdlGetRoom(&CC->room, hold_rm);        /* return to saved room */
 627
 628         syslog(LOG_DEBUG, "msgnum_being_replaced == %ld\n", msgnum_being_replaced);
 629         if (msgnum_being_replaced == 0) {
 630                 return(1);                      /* no calendar event found */
 631         }
 632
 633         /* Now we know the ID of the message containing the event being updated.
 634          * We don't actually have to delete it; that'll get taken care of by the
 635          * server when we save another event with the same UID.  This just gives
 636          * us the ability to load the event into memory so we can diddle the
 637          * attendees.
 638          */
 639         msg = CtdlFetchMessage(msgnum_being_replaced, 1);
 640         if (msg == NULL) {
 641                 return(2);                      /* internal error */
 642         }
 643         oec.c = NULL;
 644         mime_parser(msg->cm_fields[eMesageText],
 645                 NULL,
 646                 *ical_locate_original_event,    /* callback function */
 647                 NULL, NULL,
 648                 &oec,                           /* user data */
 649                 0
 650         );
 651         CtdlFreeMessage(msg);
 652
 653         original_event = oec.c;
 654         if (original_event == NULL) {
 655                 syslog(LOG_ERR, "ERROR: Original_component is NULL.\n");
 656                 return(2);
 657         }
 658
 659         /* Merge the attendee's updated status into the event */
 660         ical_merge_attendee_reply(original_event, cal);
 661
 662         /* Serialize it */
 663         serialized_event = icalcomponent_as_ical_string_r(original_event);
 664         icalcomponent_free(original_event);     /* Don't need this anymore. */
 665         if (serialized_event == NULL) return(2);
 666
 667         CtdlMailboxName(roomname, sizeof roomname, &CC->user, USERCALENDARROOM);
 668
 669         message_text = malloc(strlen(serialized_event) + SIZ);
 670         if (message_text != NULL) {
 671                 sprintf(message_text,
 672                         "Content-type: text/calendar; charset=\"utf-8\"\r\n\r\n%s\r\n",
 673                         serialized_event
 674                 );
 675
 676                 msg = CtdlMakeMessage(&CC->user,
 677                         "",                     /* No recipient */
 678                         "",                     /* No recipient */
 679                         roomname,
 680                         0, FMT_RFC822,
 681                         "",
 682                         "",
 683                         "",             /* no subject */
 684                         NULL,
 685                         message_text,
 686                         NULL);
 687
 688                 if (msg != NULL) {
 689                         CIT_ICAL->avoid_sending_invitations = 1;
 690                         CtdlSubmitMsg(msg, NULL, roomname, QP_EADDR);
 691                         CtdlFreeMessage(msg);
 692                         CIT_ICAL->avoid_sending_invitations = 0;
 693                 }
 694         }
 695         free(serialized_event);
 696         return(0);
 697 }
 698
 699
 700 /*
 701  * Handle an incoming RSVP for an event.  (This is the server subcommand part; it
 702  * simply extracts the calendar object from the message, deserializes it, and
 703  * passes it up to ical_update_my_calendar_with_reply() for processing.
 704  */
 705 void ical_handle_rsvp(long msgnum, char *partnum, char *action) {
 706         struct CtdlMessage *msg = NULL;
 707         struct ical_respond_data ird;
 708         int ret;
 709
 710         if (
 711            (strcasecmp(action, "update"))
 712            && (strcasecmp(action, "ignore"))
 713         ) {
 714                 cprintf("%d Action must be 'update' or 'ignore'\n",
 715                         ERROR + ILLEGAL_VALUE
 716                 );
 717                 return;
 718         }
 719
 720         msg = CtdlFetchMessage(msgnum, 1);
 721         if (msg == NULL) {
 722                 cprintf("%d Message %ld not found.\n",
 723                         ERROR + ILLEGAL_VALUE,
 724                         (long)msgnum
 725                 );
 726                 return;
 727         }
 728
 729         memset(&ird, 0, sizeof ird);
 730         strcpy(ird.desired_partnum, partnum);
 731         mime_parser(msg->cm_fields[eMesageText],
 732                 NULL,
 733                 *ical_locate_part,              /* callback function */
 734                 NULL, NULL,
 735                 (void *) &ird,                  /* user data */
 736                 0
 737         );
 738
 739         /* We're done with the incoming message, because we now have a
 740          * calendar object in memory.
 741          */
 742         CtdlFreeMessage(msg);
 743
 744         /*
 745          * Here is the real meat of this function.  Handle the event.
 746          */
 747         if (ird.cal != NULL) {
 748                 /* Update the user's calendar if necessary */
 749                 if (!strcasecmp(action, "update")) {
 750                         ret = ical_update_my_calendar_with_reply(ird.cal);
 751                         if (ret == 0) {
 752                                 cprintf("%d Your calendar has been updated with this reply.\n",
 753                                         CIT_OK);
 754                         }
 755                         else if (ret == 1) {
 756                                 cprintf("%d This event does not exist in your calendar.\n",
 757                                         ERROR + FILE_NOT_FOUND);
 758                         }
 759                         else {
 760                                 cprintf("%d An internal error occurred.\n",
 761                                         ERROR + INTERNAL_ERROR);
 762                         }
 763                 }
 764                 else {
 765                         cprintf("%d This reply has been ignored.\n", CIT_OK);
 766                 }
 767
 768                 /* Now that we've processed this message, we don't need it
 769                  * anymore.  So delete it.  (Don't do this anymore.)
 770                 CtdlDeleteMessages(CC->room.QRname, &msgnum, 1, "");
 771                  */
 772
 773                 /* Free the memory we allocated and return a response. */
 774                 icalcomponent_free(ird.cal);
 775                 ird.cal = NULL;
 776                 return;
 777         }
 778         else {
 779                 cprintf("%d No calendar object found\n", ERROR + ROOM_NOT_FOUND);
 780                 return;
 781         }
 782
 783         /* should never get here */
 784 }
 785
 786
 787 /*
 788  * Search for a property in both the top level and in a VEVENT subcomponent
 789  */
 790 icalproperty *ical_ctdl_get_subprop(
 791                 icalcomponent *cal,
 792                 icalproperty_kind which_prop
 793 ) {
 794         icalproperty *p;
 795         icalcomponent *c;
 796
 797         p = icalcomponent_get_first_property(cal, which_prop);
 798         if (p == NULL) {
 799                 c = icalcomponent_get_first_component(cal,
 800                                                         ICAL_VEVENT_COMPONENT);
 801                 if (c != NULL) {
 802                         p = icalcomponent_get_first_property(c, which_prop);
 803                 }
 804         }
 805         return p;
 806 }
 807
 808
 809 /*
 810  * Check to see if two events overlap.  Returns nonzero if they do.
 811  * (This function is used in both Citadel and WebCit.  If you change it in
 812  * one place, change it in the other.  Better yet, put it in a library.)
 813  */
 814 int ical_ctdl_is_overlap(
 815                         struct icaltimetype t1start,
 816                         struct icaltimetype t1end,
 817                         struct icaltimetype t2start,
 818                         struct icaltimetype t2end
 819 ) {
 820         if (icaltime_is_null_time(t1start)) return(0);
 821         if (icaltime_is_null_time(t2start)) return(0);
 822
 823         /* if either event lacks end time, assume end = start */
 824         if (icaltime_is_null_time(t1end))
 825                 memcpy(&t1end, &t1start, sizeof(struct icaltimetype));
 826         else {
 827                 if (t1end.is_date && icaltime_compare(t1start, t1end)) {
 828                         /*
 829                          * the end date is non-inclusive so adjust it by one
 830                          * day because our test is inclusive, note that a day is
 831                          * not too much because we are talking about all day
 832                          * events
 833                          * if start = end we assume that nevertheless the whole
 834                          * day is meant
 835                          */
 836                         icaltime_adjust(&t1end, -1, 0, 0, 0);
 837                 }
 838         }
 839
 840         if (icaltime_is_null_time(t2end))
 841                 memcpy(&t2end, &t2start, sizeof(struct icaltimetype));
 842         else {
 843                 if (t2end.is_date && icaltime_compare(t2start, t2end)) {
 844                         icaltime_adjust(&t2end, -1, 0, 0, 0);
 845                 }
 846         }
 847
 848         /* First, check for all-day events */
 849         if (t1start.is_date || t2start.is_date) {
 850                 /* If event 1 ends before event 2 starts, we're in the clear. */
 851                 if (icaltime_compare_date_only(t1end, t2start) < 0) return(0);
 852
 853                 /* If event 2 ends before event 1 starts, we're also ok. */
 854                 if (icaltime_compare_date_only(t2end, t1start) < 0) return(0);
 855
 856                 return(1);
 857         }
 858
 859         /* syslog(LOG_DEBUG, "Comparing t1start %d:%d t1end %d:%d t2start %d:%d t2end %d:%d \n",
 860                 t1start.hour, t1start.minute, t1end.hour, t1end.minute,
 861                 t2start.hour, t2start.minute, t2end.hour, t2end.minute);
 862         */
 863
 864         /* Now check for overlaps using date *and* time. */
 865
 866         /* If event 1 ends before event 2 starts, we're in the clear. */
 867         if (icaltime_compare(t1end, t2start) <= 0) return(0);
 868         /* syslog(LOG_DEBUG, "first passed\n"); */
 869
 870         /* If event 2 ends before event 1 starts, we're also ok. */
 871         if (icaltime_compare(t2end, t1start) <= 0) return(0);
 872         /* syslog(LOG_DEBUG, "second passed\n"); */
 873
 874         /* Otherwise, they overlap. */
 875         return(1);
 876 }
 877
 878 /*
 879  * Phase 6 of "hunt for conflicts"
 880  * called by ical_conflicts_phase5()
 881  *
 882  * Now both the proposed and existing events have been boiled down to start and end times.
 883  * Check for overlap and output any conflicts.
 884  *
 885  * Returns nonzero if a conflict was reported.  This allows the caller to stop iterating.
 886  */
 887 int ical_conflicts_phase6(struct icaltimetype t1start,
 888                         struct icaltimetype t1end,
 889                         struct icaltimetype t2start,
 890                         struct icaltimetype t2end,
 891                         long existing_msgnum,
 892                         char *conflict_event_uid,
 893                         char *conflict_event_summary,
 894                         char *compare_uid)
 895 {
 896         int conflict_reported = 0;
 897
 898         /* debugging cruft *
 899         time_t tt;
 900         tt = icaltime_as_timet_with_zone(t1start, t1start.zone);
 901         syslog(LOG_DEBUG, "PROPOSED START: %s", ctime(&tt));
 902         tt = icaltime_as_timet_with_zone(t1end, t1end.zone);
 903         syslog(LOG_DEBUG, "  PROPOSED END: %s", ctime(&tt));
 904         tt = icaltime_as_timet_with_zone(t2start, t2start.zone);
 905         syslog(LOG_DEBUG, "EXISTING START: %s", ctime(&tt));
 906         tt = icaltime_as_timet_with_zone(t2end, t2end.zone);
 907         syslog(LOG_DEBUG, "  EXISTING END: %s", ctime(&tt));
 908         * debugging cruft */
 909
 910         /* compare and output */
 911
 912         if (ical_ctdl_is_overlap(t1start, t1end, t2start, t2end)) {
 913                 cprintf("%ld||%s|%s|%d|\n",
 914                         existing_msgnum,
 915                         conflict_event_uid,
 916                         conflict_event_summary,
 917                         (       ((strlen(compare_uid)>0)
 918                                 &&(!strcasecmp(compare_uid,
 919                                 conflict_event_uid))) ? 1 : 0
 920                         )
 921                 );
 922                 conflict_reported = 1;
 923         }
 924
 925         return(conflict_reported);
 926 }
 927
 928
 929
 930 /*
 931  * Phase 5 of "hunt for conflicts"
 932  * Called by ical_conflicts_phase4()
 933  *
 934  * We have the proposed event boiled down to start and end times.
 935  * Now check it against an existing event.
 936  */
 937 void ical_conflicts_phase5(struct icaltimetype t1start,
 938                         struct icaltimetype t1end,
 939                         icalcomponent *existing_event,
 940                         long existing_msgnum,
 941                         char *compare_uid)
 942 {
 943         char conflict_event_uid[SIZ];
 944         char conflict_event_summary[SIZ];
 945         struct icaltimetype t2start, t2end;
 946         icalproperty *p;
 947
 948         /* recur variables */
 949         icalproperty *rrule = NULL;
 950         struct icalrecurrencetype recur;
 951         icalrecur_iterator *ritr = NULL;
 952         struct icaldurationtype dur;
 953         int num_recur = 0;
 954
 955         /* initialization */
 956         strcpy(conflict_event_uid, "");
 957         strcpy(conflict_event_summary, "");
 958         t2start = icaltime_null_time();
 959         t2end = icaltime_null_time();
 960
 961         /* existing event stuff */
 962         p = ical_ctdl_get_subprop(existing_event, ICAL_DTSTART_PROPERTY);
 963         if (p == NULL) return;
 964         if (p != NULL) t2start = icalproperty_get_dtstart(p);
 965         if (icaltime_is_utc(t2start)) {
 966                 t2start.zone = icaltimezone_get_utc_timezone();
 967         }
 968         else {
 969                 t2start.zone = icalcomponent_get_timezone(existing_event,
 970                         icalparameter_get_tzid(
 971                                 icalproperty_get_first_parameter(p, ICAL_TZID_PARAMETER)
 972                         )
 973                 );
 974                 if (!t2start.zone) {
 975                         t2start.zone = get_default_icaltimezone();
 976                 }
 977         }
 978
 979         p = ical_ctdl_get_subprop(existing_event, ICAL_DTEND_PROPERTY);
 980         if (p != NULL) {
 981                 t2end = icalproperty_get_dtend(p);
 982
 983                 if (icaltime_is_utc(t2end)) {
 984                         t2end.zone = icaltimezone_get_utc_timezone();
 985                 }
 986                 else {
 987                         t2end.zone = icalcomponent_get_timezone(existing_event,
 988                                 icalparameter_get_tzid(
 989                                         icalproperty_get_first_parameter(p, ICAL_TZID_PARAMETER)
 990                                 )
 991                         );
 992                         if (!t2end.zone) {
 993                                 t2end.zone = get_default_icaltimezone();
 994                         }
 995                 }
 996                 dur = icaltime_subtract(t2end, t2start);
 997         }
 998         else {
 999                 memset (&dur, 0, sizeof(struct icaldurationtype));
1000         }
1001
1002         rrule = ical_ctdl_get_subprop(existing_event, ICAL_RRULE_PROPERTY);
1003         if (rrule) {
1004                 recur = icalproperty_get_rrule(rrule);
1005                 ritr = icalrecur_iterator_new(recur, t2start);
1006         }
1007
1008         do {
1009                 p = ical_ctdl_get_subprop(existing_event, ICAL_UID_PROPERTY);
1010                 if (p != NULL) {
1011                         strcpy(conflict_event_uid, icalproperty_get_comment(p));
1012                 }
1013
1014                 p = ical_ctdl_get_subprop(existing_event, ICAL_SUMMARY_PROPERTY);
1015                 if (p != NULL) {
1016                         strcpy(conflict_event_summary, icalproperty_get_comment(p));
1017                 }
1018
1019                 if (ical_conflicts_phase6(t1start, t1end, t2start, t2end,
1020                    existing_msgnum, conflict_event_uid, conflict_event_summary, compare_uid))
1021                 {
1022                         num_recur = MAX_RECUR + 1;      /* force it out of scope, no need to continue */
1023                 }
1024
1025                 if (rrule) {
1026                         t2start = icalrecur_iterator_next(ritr);
1027                         if (!icaltime_is_null_time(t2end)) {
1028                                 const icaltimezone *hold_zone = t2end.zone;
1029                                 t2end = icaltime_add(t2start, dur);
1030                                 t2end.zone = hold_zone;
1031                         }
1032                         ++num_recur;
1033                 }
1034
1035                 if (icaltime_compare(t2start, t1end) < 0) {
1036                         num_recur = MAX_RECUR + 1;      /* force it out of scope */
1037                 }
1038
1039         } while ( (rrule) && (!icaltime_is_null_time(t2start)) && (num_recur < MAX_RECUR) );
1040         icalrecur_iterator_free(ritr);
1041 }
1042
1043
1044
1045
1046 /*
1047  * Phase 4 of "hunt for conflicts"
1048  * Called by ical_hunt_for_conflicts_backend()
1049  *
1050  * At this point we've got it boiled down to two icalcomponent events in memory.
1051  * If they conflict, output something to the client.
1052  */
1053 void ical_conflicts_phase4(icalcomponent *proposed_event,
1054                 icalcomponent *existing_event,
1055                 long existing_msgnum)
1056 {
1057         struct icaltimetype t1start, t1end;
1058         icalproperty *p;
1059         char compare_uid[SIZ];
1060
1061         /* recur variables */
1062         icalproperty *rrule = NULL;
1063         struct icalrecurrencetype recur;
1064         icalrecur_iterator *ritr = NULL;
1065         struct icaldurationtype dur;
1066         int num_recur = 0;
1067
1068         /* initialization */
1069         t1end = icaltime_null_time();
1070         *compare_uid = '\0';
1071
1072         /* proposed event stuff */
1073
1074         p = ical_ctdl_get_subprop(proposed_event, ICAL_DTSTART_PROPERTY);
1075         if (p == NULL)
1076                 return;
1077         else
1078                 t1start = icalproperty_get_dtstart(p);
1079
1080         if (icaltime_is_utc(t1start)) {
1081                 t1start.zone = icaltimezone_get_utc_timezone();
1082         }
1083         else {
1084                 t1start.zone = icalcomponent_get_timezone(proposed_event,
1085                         icalparameter_get_tzid(
1086                                 icalproperty_get_first_parameter(p, ICAL_TZID_PARAMETER)
1087                         )
1088                 );
1089                 if (!t1start.zone) {
1090                         t1start.zone = get_default_icaltimezone();
1091                 }
1092         }
1093
1094         p = ical_ctdl_get_subprop(proposed_event, ICAL_DTEND_PROPERTY);
1095         if (p != NULL) {
1096                 t1end = icalproperty_get_dtend(p);
1097
1098                 if (icaltime_is_utc(t1end)) {
1099                         t1end.zone = icaltimezone_get_utc_timezone();
1100                 }
1101                 else {
1102                         t1end.zone = icalcomponent_get_timezone(proposed_event,
1103                                 icalparameter_get_tzid(
1104                                         icalproperty_get_first_parameter(p, ICAL_TZID_PARAMETER)
1105                                 )
1106                         );
1107                         if (!t1end.zone) {
1108                                 t1end.zone = get_default_icaltimezone();
1109                         }
1110                 }
1111
1112                 dur = icaltime_subtract(t1end, t1start);
1113         }
1114         else {
1115                 memset (&dur, 0, sizeof(struct icaldurationtype));
1116         }
1117
1118         rrule = ical_ctdl_get_subprop(proposed_event, ICAL_RRULE_PROPERTY);
1119         if (rrule) {
1120                 recur = icalproperty_get_rrule(rrule);
1121                 ritr = icalrecur_iterator_new(recur, t1start);
1122         }
1123
1124         p = ical_ctdl_get_subprop(proposed_event, ICAL_UID_PROPERTY);
1125         if (p != NULL) {
1126                 strcpy(compare_uid, icalproperty_get_comment(p));
1127         }
1128
1129         do {
1130                 ical_conflicts_phase5(t1start, t1end, existing_event, existing_msgnum, compare_uid);
1131
1132                 if (rrule) {
1133                         t1start = icalrecur_iterator_next(ritr);
1134                         if (!icaltime_is_null_time(t1end)) {
1135                                 const icaltimezone *hold_zone = t1end.zone;
1136                                 t1end = icaltime_add(t1start, dur);
1137                                 t1end.zone = hold_zone;
1138                         }
1139                         ++num_recur;
1140                 }
1141
1142         } while ( (rrule) && (!icaltime_is_null_time(t1start)) && (num_recur < MAX_RECUR) );
1143         icalrecur_iterator_free(ritr);
1144 }
1145
1146
1147
1148 /*
1149  * Phase 3 of "hunt for conflicts"
1150  * Called by ical_hunt_for_conflicts()
1151  */
1152 void ical_hunt_for_conflicts_backend(long msgnum, void *data) {
1153         icalcomponent *proposed_event;
1154         struct CtdlMessage *msg = NULL;
1155         struct ical_respond_data ird;
1156
1157         proposed_event = (icalcomponent *)data;
1158
1159         msg = CtdlFetchMessage(msgnum, 1);
1160         if (msg == NULL) return;
1161         memset(&ird, 0, sizeof ird);
1162         strcpy(ird.desired_partnum, "_HUNT_");
1163         mime_parser(msg->cm_fields[eMesageText],
1164                 NULL,
1165                 *ical_locate_part,              /* callback function */
1166                 NULL, NULL,
1167                 (void *) &ird,                  /* user data */
1168                 0
1169         );
1170         CtdlFreeMessage(msg);
1171
1172         if (ird.cal == NULL) return;
1173
1174         ical_conflicts_phase4(proposed_event, ird.cal, msgnum);
1175         icalcomponent_free(ird.cal);
1176 }
1177
1178
1179
1180 /*
1181  * Phase 2 of "hunt for conflicts" operation.
1182  * At this point we have a calendar object which represents the VEVENT that
1183  * is proposed for addition to the calendar.  Now hunt through the user's
1184  * calendar room, and output zero or more existing VEVENTs which conflict
1185  * with this one.
1186  */
1187 void ical_hunt_for_conflicts(icalcomponent *cal) {
1188         char hold_rm[ROOMNAMELEN];
1189
1190         strcpy(hold_rm, CC->room.QRname);       /* save current room */
1191
1192         if (CtdlGetRoom(&CC->room, USERCALENDARROOM) != 0) {
1193                 CtdlGetRoom(&CC->room, hold_rm);
1194                 cprintf("%d You do not have a calendar.\n", ERROR + ROOM_NOT_FOUND);
1195                 return;
1196         }
1197
1198         cprintf("%d Conflicting events:\n", LISTING_FOLLOWS);
1199
1200         CtdlForEachMessage(MSGS_ALL, 0, NULL,
1201                 NULL,
1202                 NULL,
1203                 ical_hunt_for_conflicts_backend,
1204                 (void *) cal
1205         );
1206
1207         cprintf("000\n");
1208         CtdlGetRoom(&CC->room, hold_rm);        /* return to saved room */
1209
1210 }
1211
1212
1213
1214 /*
1215  * Hunt for conflicts (Phase 1 -- retrieve the object and call Phase 2)
1216  */
1217 void ical_conflicts(long msgnum, char *partnum) {
1218         struct CtdlMessage *msg = NULL;
1219         struct ical_respond_data ird;
1220
1221         msg = CtdlFetchMessage(msgnum, 1);
1222         if (msg == NULL) {
1223                 cprintf("%d Message %ld not found\n",
1224                         ERROR + ILLEGAL_VALUE,
1225                         (long)msgnum
1226                 );
1227                 return;
1228         }
1229
1230         memset(&ird, 0, sizeof ird);
1231         strcpy(ird.desired_partnum, partnum);
1232         mime_parser(msg->cm_fields[eMesageText],
1233                 NULL,
1234                 *ical_locate_part,              /* callback function */
1235                 NULL, NULL,
1236                 (void *) &ird,                  /* user data */
1237                 0
1238         );
1239
1240         CtdlFreeMessage(msg);
1241
1242         if (ird.cal != NULL) {
1243                 ical_hunt_for_conflicts(ird.cal);
1244                 icalcomponent_free(ird.cal);
1245                 return;
1246         }
1247
1248         cprintf("%d No calendar object found\n", ERROR + ROOM_NOT_FOUND);
1249 }
1250
1251
1252
1253 /*
1254  * Look for busy time in a VEVENT and add it to the supplied VFREEBUSY.
1255  *
1256  * fb                   The VFREEBUSY component to which we are appending
1257  * top_level_cal        The top-level VCALENDAR component which contains a VEVENT to be added
1258  */
1259 void ical_add_to_freebusy(icalcomponent *fb, icalcomponent *top_level_cal) {
1260         icalcomponent *cal;
1261         icalproperty *p;
1262         icalvalue *v;
1263         struct icalperiodtype this_event_period = icalperiodtype_null_period();
1264         icaltimetype dtstart;
1265         icaltimetype dtend;
1266
1267         /* recur variables */
1268         icalproperty *rrule = NULL;
1269         struct icalrecurrencetype recur;
1270         icalrecur_iterator *ritr = NULL;
1271         struct icaldurationtype dur;
1272         int num_recur = 0;
1273
1274         if (!top_level_cal) return;
1275
1276         /* Find the VEVENT component containing an event */
1277         cal = icalcomponent_get_first_component(top_level_cal, ICAL_VEVENT_COMPONENT);
1278         if (!cal) return;
1279
1280         /* If this event is not opaque, the user isn't publishing it as
1281          * busy time, so don't bother doing anything else.
1282          */
1283         p = icalcomponent_get_first_property(cal, ICAL_TRANSP_PROPERTY);
1284         if (p != NULL) {
1285                 v = icalproperty_get_value(p);
1286                 if (v != NULL) {
1287                         if (icalvalue_get_transp(v) != ICAL_TRANSP_OPAQUE) {
1288                                 return;
1289                         }
1290                 }
1291         }
1292
1293         /*
1294          * Now begin calculating the event start and end times.
1295          */
1296         p = icalcomponent_get_first_property(cal, ICAL_DTSTART_PROPERTY);
1297         if (!p) return;
1298         dtstart = icalproperty_get_dtstart(p);
1299
1300         if (icaltime_is_utc(dtstart)) {
1301                 dtstart.zone = icaltimezone_get_utc_timezone();
1302         }
1303         else {
1304                 dtstart.zone = icalcomponent_get_timezone(top_level_cal,
1305                         icalparameter_get_tzid(
1306                                 icalproperty_get_first_parameter(p, ICAL_TZID_PARAMETER)
1307                         )
1308                 );
1309                 if (!dtstart.zone) {
1310                         dtstart.zone = get_default_icaltimezone();
1311                 }
1312         }
1313
1314         dtend = icalcomponent_get_dtend(cal);
1315         if (!icaltime_is_null_time(dtend)) {
1316                 dur = icaltime_subtract(dtend, dtstart);
1317         }
1318         else {
1319                 memset (&dur, 0, sizeof(struct icaldurationtype));
1320         }
1321
1322         /* Is a recurrence specified?  If so, get ready to process it... */
1323         rrule = ical_ctdl_get_subprop(cal, ICAL_RRULE_PROPERTY);
1324         if (rrule) {
1325                 recur = icalproperty_get_rrule(rrule);
1326                 ritr = icalrecur_iterator_new(recur, dtstart);
1327         }
1328
1329         do {
1330                 /* Convert the DTSTART and DTEND properties to an icalperiod. */
1331                 this_event_period.start = dtstart;
1332
1333                 if (!icaltime_is_null_time(dtend)) {
1334                         this_event_period.end = dtend;
1335                 }
1336
1337                 /* Convert the timestamps to UTC.  It's ok to do this because we've already expanded
1338                  * recurrences and this data is never going to get used again.
1339                  */
1340                 this_event_period.start = icaltime_convert_to_zone(
1341                         this_event_period.start,
1342                         icaltimezone_get_utc_timezone()
1343                 );
1344                 this_event_period.end = icaltime_convert_to_zone(
1345                         this_event_period.end,
1346                         icaltimezone_get_utc_timezone()
1347                 );
1348
1349                 /* Now add it. */
1350                 icalcomponent_add_property(fb, icalproperty_new_freebusy(this_event_period));
1351
1352                 /* Make sure the DTSTART property of the freebusy *list* is set to
1353                  * the DTSTART property of the *earliest event*.
1354                  */
1355                 p = icalcomponent_get_first_property(fb, ICAL_DTSTART_PROPERTY);
1356                 if (p == NULL) {
1357                         icalcomponent_set_dtstart(fb, this_event_period.start);
1358                 }
1359                 else {
1360                         if (icaltime_compare(this_event_period.start, icalcomponent_get_dtstart(fb)) < 0) {
1361                                 icalcomponent_set_dtstart(fb, this_event_period.start);
1362                         }
1363                 }
1364
1365                 /* Make sure the DTEND property of the freebusy *list* is set to
1366                  * the DTEND property of the *latest event*.
1367                  */
1368                 p = icalcomponent_get_first_property(fb, ICAL_DTEND_PROPERTY);
1369                 if (p == NULL) {
1370                         icalcomponent_set_dtend(fb, this_event_period.end);
1371                 }
1372                 else {
1373                         if (icaltime_compare(this_event_period.end, icalcomponent_get_dtend(fb)) > 0) {
1374                                 icalcomponent_set_dtend(fb, this_event_period.end);
1375                         }
1376                 }
1377
1378                 if (rrule) {
1379                         dtstart = icalrecur_iterator_next(ritr);
1380                         if (!icaltime_is_null_time(dtend)) {
1381                                 dtend = icaltime_add(dtstart, dur);
1382                                 dtend.zone = dtstart.zone;
1383                                 dtend.is_utc = dtstart.is_utc;
1384                         }
1385                         ++num_recur;
1386                 }
1387
1388         } while ( (rrule) && (!icaltime_is_null_time(dtstart)) && (num_recur < MAX_RECUR) ) ;
1389         icalrecur_iterator_free(ritr);
1390 }
1391
1392
1393
1394 /*
1395  * Backend for ical_freebusy()
1396  *
1397  * This function simply loads the messages in the user's calendar room,
1398  * which contain VEVENTs, then strips them of all non-freebusy data, and
1399  * adds them to the supplied VCALENDAR.
1400  *
1401  */
1402 void ical_freebusy_backend(long msgnum, void *data) {
1403         icalcomponent *fb;
1404         struct CtdlMessage *msg = NULL;
1405         struct ical_respond_data ird;
1406
1407         fb = (icalcomponent *)data;             /* User-supplied data will be the VFREEBUSY component */
1408
1409         msg = CtdlFetchMessage(msgnum, 1);
1410         if (msg == NULL) return;
1411         memset(&ird, 0, sizeof ird);
1412         strcpy(ird.desired_partnum, "_HUNT_");
1413         mime_parser(msg->cm_fields[eMesageText],
1414                 NULL,
1415                 *ical_locate_part,              /* callback function */
1416                 NULL, NULL,
1417                 (void *) &ird,                  /* user data */
1418                 0
1419         );
1420         CtdlFreeMessage(msg);
1421
1422         if (ird.cal) {
1423                 ical_add_to_freebusy(fb, ird.cal);              /* Add VEVENT times to VFREEBUSY */
1424                 icalcomponent_free(ird.cal);
1425         }
1426 }
1427
1428
1429
1430 /*
1431  * Grab another user's free/busy times
1432  */
1433 void ical_freebusy(char *who) {
1434         struct ctdluser usbuf;
1435         char calendar_room_name[ROOMNAMELEN];
1436         char hold_rm[ROOMNAMELEN];
1437         char *serialized_request = NULL;
1438         icalcomponent *encaps = NULL;
1439         icalcomponent *fb = NULL;
1440         int found_user = (-1);
1441         struct recptypes *recp = NULL;
1442         char buf[256];
1443         char host[256];
1444         char type[256];
1445         int i = 0;
1446         int config_lines = 0;
1447
1448         /* First try an exact match. */
1449         found_user = CtdlGetUser(&usbuf, who);
1450
1451         /* If not found, try it as an unqualified email address. */
1452         if (found_user != 0) {
1453                 strcpy(buf, who);
1454                 recp = validate_recipients(buf, NULL, 0);
1455                 syslog(LOG_DEBUG, "Trying <%s>\n", buf);
1456                 if (recp != NULL) {
1457                         if (recp->num_local == 1) {
1458                                 found_user = CtdlGetUser(&usbuf, recp->recp_local);
1459                         }
1460                         free_recipients(recp);
1461                 }
1462         }
1463
1464         /* If still not found, try it as an address qualified with the
1465          * primary FQDN of this Citadel node.
1466          */
1467         if (found_user != 0) {
1468                 snprintf(buf, sizeof buf, "%s@%s", who, config.c_fqdn);
1469                 syslog(LOG_DEBUG, "Trying <%s>\n", buf);
1470                 recp = validate_recipients(buf, NULL, 0);
1471                 if (recp != NULL) {
1472                         if (recp->num_local == 1) {
1473                                 found_user = CtdlGetUser(&usbuf, recp->recp_local);
1474                         }
1475                         free_recipients(recp);
1476                 }
1477         }
1478
1479         /* Still not found?  Try qualifying it with every domain we
1480          * might have addresses in.
1481          */
1482         if (found_user != 0) {
1483                 config_lines = num_tokens(inetcfg, '\n');
1484                 for (i=0; ((i < config_lines) && (found_user != 0)); ++i) {
1485                         extract_token(buf, inetcfg, i, '\n', sizeof buf);
1486                         extract_token(host, buf, 0, '|', sizeof host);
1487                         extract_token(type, buf, 1, '|', sizeof type);
1488
1489                         if ( (!strcasecmp(type, "localhost"))
1490                            || (!strcasecmp(type, "directory")) ) {
1491                                 snprintf(buf, sizeof buf, "%s@%s", who, host);
1492                                 syslog(LOG_DEBUG, "Trying <%s>\n", buf);
1493                                 recp = validate_recipients(buf, NULL, 0);
1494                                 if (recp != NULL) {
1495                                         if (recp->num_local == 1) {
1496                                                 found_user = CtdlGetUser(&usbuf, recp->recp_local);
1497                                         }
1498                                         free_recipients(recp);
1499                                 }
1500                         }
1501                 }
1502         }
1503
1504         if (found_user != 0) {
1505                 cprintf("%d No such user.\n", ERROR + NO_SUCH_USER);
1506                 return;
1507         }
1508
1509         CtdlMailboxName(calendar_room_name, sizeof calendar_room_name,
1510                 &usbuf, USERCALENDARROOM);
1511
1512         strcpy(hold_rm, CC->room.QRname);       /* save current room */
1513
1514         if (CtdlGetRoom(&CC->room, calendar_room_name) != 0) {
1515                 cprintf("%d Cannot open calendar\n", ERROR + ROOM_NOT_FOUND);
1516                 CtdlGetRoom(&CC->room, hold_rm);
1517                 return;
1518         }
1519
1520         /* Create a VFREEBUSY subcomponent */
1521         syslog(LOG_DEBUG, "Creating VFREEBUSY component\n");
1522         fb = icalcomponent_new_vfreebusy();
1523         if (fb == NULL) {
1524                 cprintf("%d Internal error: cannot allocate memory.\n",
1525                         ERROR + INTERNAL_ERROR);
1526                 CtdlGetRoom(&CC->room, hold_rm);
1527                 return;
1528         }
1529
1530         /* Set the method to PUBLISH */
1531         icalcomponent_set_method(fb, ICAL_METHOD_PUBLISH);
1532
1533         /* Set the DTSTAMP to right now. */
1534         icalcomponent_set_dtstamp(fb, icaltime_from_timet(time(NULL), 0));
1535
1536         /* Add the user's email address as ORGANIZER */
1537         sprintf(buf, "MAILTO:%s", who);
1538         if (strchr(buf, '@') == NULL) {
1539                 strcat(buf, "@");
1540                 strcat(buf, config.c_fqdn);
1541         }
1542         for (i=0; buf[i]; ++i) {
1543                 if (buf[i]==' ') buf[i] = '_';
1544         }
1545         icalcomponent_add_property(fb, icalproperty_new_organizer(buf));
1546
1547         /* Add busy time from events */
1548         syslog(LOG_DEBUG, "Adding busy time from events\n");
1549         CtdlForEachMessage(MSGS_ALL, 0, NULL, NULL, NULL, ical_freebusy_backend, (void *)fb );
1550
1551         /* If values for DTSTART and DTEND are still not present, set them
1552          * to yesterday and tomorrow as default values.
1553          */
1554         if (icalcomponent_get_first_property(fb, ICAL_DTSTART_PROPERTY) == NULL) {
1555                 icalcomponent_set_dtstart(fb, icaltime_from_timet(time(NULL)-86400L, 0));
1556         }
1557         if (icalcomponent_get_first_property(fb, ICAL_DTEND_PROPERTY) == NULL) {
1558                 icalcomponent_set_dtend(fb, icaltime_from_timet(time(NULL)+86400L, 0));
1559         }
1560
1561         /* Put the freebusy component into the calendar component */
1562         syslog(LOG_DEBUG, "Encapsulating\n");
1563         encaps = ical_encapsulate_subcomponent(fb);
1564         if (encaps == NULL) {
1565                 icalcomponent_free(fb);
1566                 cprintf("%d Internal error: cannot allocate memory.\n",
1567                         ERROR + INTERNAL_ERROR);
1568                 CtdlGetRoom(&CC->room, hold_rm);
1569                 return;
1570         }
1571
1572         /* Set the method to PUBLISH */
1573         syslog(LOG_DEBUG, "Setting method\n");
1574         icalcomponent_set_method(encaps, ICAL_METHOD_PUBLISH);
1575
1576         /* Serialize it */
1577         syslog(LOG_DEBUG, "Serializing\n");
1578         serialized_request = icalcomponent_as_ical_string_r(encaps);
1579         icalcomponent_free(encaps);     /* Don't need this anymore. */
1580
1581         cprintf("%d Free/busy for %s\n", LISTING_FOLLOWS, usbuf.fullname);
1582         if (serialized_request != NULL) {
1583                 client_write(serialized_request, strlen(serialized_request));
1584                 free(serialized_request);
1585         }
1586         cprintf("\n000\n");
1587
1588         /* Go back to the room from which we came... */
1589         CtdlGetRoom(&CC->room, hold_rm);
1590 }
1591
1592
1593
1594 /*
1595  * Backend for ical_getics()
1596  *
1597  * This is a ForEachMessage() callback function that searches the current room
1598  * for calendar events and adds them each into one big calendar component.
1599  */
1600 void ical_getics_backend(long msgnum, void *data) {
1601         icalcomponent *encaps, *c;
1602         struct CtdlMessage *msg = NULL;
1603         struct ical_respond_data ird;
1604
1605         encaps = (icalcomponent *)data;
1606         if (encaps == NULL) return;
1607
1608         /* Look for the calendar event... */
1609
1610         msg = CtdlFetchMessage(msgnum, 1);
1611         if (msg == NULL) return;
1612         memset(&ird, 0, sizeof ird);
1613         strcpy(ird.desired_partnum, "_HUNT_");
1614         mime_parser(msg->cm_fields[eMesageText],
1615                 NULL,
1616                 *ical_locate_part,              /* callback function */
1617                 NULL, NULL,
1618                 (void *) &ird,                  /* user data */
1619                 0
1620         );
1621         CtdlFreeMessage(msg);
1622
1623         if (ird.cal == NULL) return;
1624
1625         /* Here we go: put the VEVENT into the VCALENDAR.  We now no longer
1626          * are responsible for "the_request"'s memory -- it will be freed
1627          * when we free "encaps".
1628          */
1629
1630         /* If the top-level component is *not* a VCALENDAR, we can drop it right
1631          * in.  This will almost never happen.
1632          */
1633         if (icalcomponent_isa(ird.cal) != ICAL_VCALENDAR_COMPONENT) {
1634                 icalcomponent_add_component(encaps, ird.cal);
1635         }
1636         /*
1637          * In the more likely event that we're looking at a VCALENDAR with the VEVENT
1638          * and other components encapsulated inside, we have to extract them.
1639          */
1640         else {
1641                 for (c = icalcomponent_get_first_component(ird.cal, ICAL_ANY_COMPONENT);
1642                     (c != NULL);
1643                     c = icalcomponent_get_next_component(ird.cal, ICAL_ANY_COMPONENT)) {
1644
1645                         /* For VTIMEZONE components, suppress duplicates of the same tzid */
1646
1647                         if (icalcomponent_isa(c) == ICAL_VTIMEZONE_COMPONENT) {
1648                                 icalproperty *p = icalcomponent_get_first_property(c, ICAL_TZID_PROPERTY);
1649                                 if (p) {
1650                                         const char *tzid = icalproperty_get_tzid(p);
1651                                         if (!icalcomponent_get_timezone(encaps, tzid)) {
1652                                                 icalcomponent_add_component(encaps,
1653                                                                         icalcomponent_new_clone(c));
1654                                         }
1655                                 }
1656                         }
1657
1658                         /* All other types of components can go in verbatim */
1659                         else {
1660                                 icalcomponent_add_component(encaps, icalcomponent_new_clone(c));
1661                         }
1662                 }
1663                 icalcomponent_free(ird.cal);
1664         }
1665 }
1666
1667
1668
1669 /*
1670  * Retrieve all of the calendar items in the current room, and output them
1671  * as a single icalendar object.
1672  */
1673 void ical_getics(void)
1674 {
1675         icalcomponent *encaps = NULL;
1676         char *ser = NULL;
1677
1678         if ( (CC->room.QRdefaultview != VIEW_CALENDAR)
1679            &&(CC->room.QRdefaultview != VIEW_TASKS) ) {
1680                 cprintf("%d Not a calendar room\n", ERROR+NOT_HERE);
1681                 return;         /* Not an iCalendar-centric room */
1682         }
1683
1684         encaps = icalcomponent_new_vcalendar();
1685         if (encaps == NULL) {
1686                 syslog(LOG_ALERT, "ERROR: could not allocate component!\n");
1687                 cprintf("%d Could not allocate memory\n", ERROR+INTERNAL_ERROR);
1688                 return;
1689         }
1690
1691         cprintf("%d one big calendar\n", LISTING_FOLLOWS);
1692
1693         /* Set the Product ID */
1694         icalcomponent_add_property(encaps, icalproperty_new_prodid(PRODID));
1695
1696         /* Set the Version Number */
1697         icalcomponent_add_property(encaps, icalproperty_new_version("2.0"));
1698
1699         /* Set the method to PUBLISH */
1700         icalcomponent_set_method(encaps, ICAL_METHOD_PUBLISH);
1701
1702         /* Now go through the room encapsulating all calendar items. */
1703         CtdlForEachMessage(MSGS_ALL, 0, NULL,
1704                 NULL,
1705                 NULL,
1706                 ical_getics_backend,
1707                 (void *) encaps
1708         );
1709
1710         ser = icalcomponent_as_ical_string_r(encaps);
1711         icalcomponent_free(encaps);                     /* Don't need this anymore. */
1712         client_write(ser, strlen(ser));
1713         free(ser);
1714         cprintf("\n000\n");
1715 }
1716
1717
1718 /*
1719  * Helper callback function for ical_putics() to discover which TZID's we need.
1720  * Simply put the tzid name string into a hash table.  After the callbacks are
1721  * done we'll go through them and attach the ones that we have.
1722  */
1723 void ical_putics_grabtzids(icalparameter *param, void *data)
1724 {
1725         const char *tzid = icalparameter_get_tzid(param);
1726         HashList *keys = (HashList *) data;
1727
1728         if ( (keys) && (tzid) && (!IsEmptyStr(tzid)) ) {
1729                 Put(keys, tzid, strlen(tzid), strdup(tzid), NULL);
1730         }
1731 }
1732
1733
1734 /*
1735  * Delete all of the calendar items in the current room, and replace them
1736  * with calendar items from a client-supplied data stream.
1737  */
1738 void ical_putics(void)
1739 {
1740         char *calstream = NULL;
1741         icalcomponent *cal;
1742         icalcomponent *c;
1743         icalcomponent *encaps = NULL;
1744         HashList *tzidlist = NULL;
1745         HashPos *HashPos;
1746         void *Value;
1747         const char *Key;
1748         long len;
1749
1750         /* Only allow this operation if we're in a room containing a calendar or tasks view */
1751         if ( (CC->room.QRdefaultview != VIEW_CALENDAR)
1752            &&(CC->room.QRdefaultview != VIEW_TASKS) ) {
1753                 cprintf("%d Not a calendar room\n", ERROR+NOT_HERE);
1754                 return;
1755         }
1756
1757         /* Only allow this operation if we have permission to overwrite the existing calendar */
1758         if (!CtdlDoIHavePermissionToDeleteMessagesFromThisRoom()) {
1759                 cprintf("%d Permission denied.\n", ERROR+HIGHER_ACCESS_REQUIRED);
1760                 return;
1761         }
1762
1763         cprintf("%d Transmit data now\n", SEND_LISTING);
1764         calstream = CtdlReadMessageBody(HKEY("000"), config.c_maxmsglen, NULL, 0, 0);
1765         if (calstream == NULL) {
1766                 return;
1767         }
1768
1769         cal = icalcomponent_new_from_string(calstream);
1770         free(calstream);
1771
1772         /* We got our data stream -- now do something with it. */
1773
1774         /* Delete the existing messages in the room, because we are overwriting
1775          * the entire calendar with an entire new (or updated) calendar.
1776          * (Careful: this opens an S_ROOMS critical section!)
1777          */
1778         CtdlDeleteMessages(CC->room.QRname, NULL, 0, "");
1779
1780         /* If the top-level component is *not* a VCALENDAR, we can drop it right
1781          * in.  This will almost never happen.
1782          */
1783         if (icalcomponent_isa(cal) != ICAL_VCALENDAR_COMPONENT) {
1784                 ical_write_to_cal(NULL, cal);
1785         }
1786         /*
1787          * In the more likely event that we're looking at a VCALENDAR with the VEVENT
1788          * and other components encapsulated inside, we have to extract them.
1789          */
1790         else {
1791                 for (c = icalcomponent_get_first_component(cal, ICAL_ANY_COMPONENT);
1792                     (c != NULL);
1793                     c = icalcomponent_get_next_component(cal, ICAL_ANY_COMPONENT)) {
1794
1795                         /* Non-VTIMEZONE components each get written as individual messages.
1796                          * But we also need to attach the relevant VTIMEZONE components to them.
1797                          */
1798                         if ( (icalcomponent_isa(c) != ICAL_VTIMEZONE_COMPONENT)
1799                            && (encaps = icalcomponent_new_vcalendar()) ) {
1800                                 icalcomponent_add_property(encaps, icalproperty_new_prodid(PRODID));
1801                                 icalcomponent_add_property(encaps, icalproperty_new_version("2.0"));
1802                                 icalcomponent_set_method(encaps, ICAL_METHOD_PUBLISH);
1803
1804                                 /* Attach any needed timezones here */
1805                                 tzidlist = NewHash(1, NULL);
1806                                 if (tzidlist) {
1807                                         icalcomponent_foreach_tzid(c, ical_putics_grabtzids, tzidlist);
1808                                 }
1809                                 HashPos = GetNewHashPos(tzidlist, 0);
1810
1811                                 while (GetNextHashPos(tzidlist, HashPos, &len, &Key, &Value)) {
1812                                         syslog(LOG_DEBUG, "Attaching timezone '%s'\n", (char*) Value);
1813                                         icaltimezone *t = NULL;
1814
1815                                         /* First look for a timezone attached to the original calendar */
1816                                         t = icalcomponent_get_timezone(cal, Value);
1817
1818                                         /* Try built-in tzdata if the right one wasn't attached */
1819                                         if (!t) {
1820                                                 t = icaltimezone_get_builtin_timezone(Value);
1821                                         }
1822
1823                                         /* I've got a valid timezone to attach. */
1824                                         if (t) {
1825                                                 icalcomponent_add_component(encaps,
1826                                                         icalcomponent_new_clone(
1827                                                                 icaltimezone_get_component(t)
1828                                                         )
1829                                                 );
1830                                         }
1831
1832                                 }
1833                                 DeleteHashPos(&HashPos);
1834                                 DeleteHash(&tzidlist);
1835
1836                                 /* Now attach the component itself (usually a VEVENT or VTODO) */
1837                                 icalcomponent_add_component(encaps, icalcomponent_new_clone(c));
1838
1839                                 /* Write it to the message store */
1840                                 ical_write_to_cal(NULL, encaps);
1841                                 icalcomponent_free(encaps);
1842                         }
1843                 }
1844         }
1845
1846         icalcomponent_free(cal);
1847 }
1848
1849
1850 /*
1851  * All Citadel calendar commands from the client come through here.
1852  */
1853 void cmd_ical(char *argbuf)
1854 {
1855         char subcmd[64];
1856         long msgnum;
1857         char partnum[256];
1858         char action[256];
1859         char who[256];
1860
1861         extract_token(subcmd, argbuf, 0, '|', sizeof subcmd);
1862
1863         /* Allow "test" and "freebusy" subcommands without logging in. */
1864
1865         if (!strcasecmp(subcmd, "test")) {
1866                 cprintf("%d This server supports calendaring\n", CIT_OK);
1867                 return;
1868         }
1869
1870         if (!strcasecmp(subcmd, "freebusy")) {
1871                 extract_token(who, argbuf, 1, '|', sizeof who);
1872                 ical_freebusy(who);
1873                 return;
1874         }
1875
1876         if (!strcasecmp(subcmd, "sgi")) {
1877                 CIT_ICAL->server_generated_invitations =
1878                         (extract_int(argbuf, 1) ? 1 : 0) ;
1879                 cprintf("%d %d\n",
1880                         CIT_OK, CIT_ICAL->server_generated_invitations);
1881                 return;
1882         }
1883
1884         if (CtdlAccessCheck(ac_logged_in)) return;
1885
1886         if (!strcasecmp(subcmd, "respond")) {
1887                 msgnum = extract_long(argbuf, 1);
1888                 extract_token(partnum, argbuf, 2, '|', sizeof partnum);
1889                 extract_token(action, argbuf, 3, '|', sizeof action);
1890                 ical_respond(msgnum, partnum, action);
1891                 return;
1892         }
1893
1894         if (!strcasecmp(subcmd, "handle_rsvp")) {
1895                 msgnum = extract_long(argbuf, 1);
1896                 extract_token(partnum, argbuf, 2, '|', sizeof partnum);
1897                 extract_token(action, argbuf, 3, '|', sizeof action);
1898                 ical_handle_rsvp(msgnum, partnum, action);
1899                 return;
1900         }
1901
1902         if (!strcasecmp(subcmd, "conflicts")) {
1903                 msgnum = extract_long(argbuf, 1);
1904                 extract_token(partnum, argbuf, 2, '|', sizeof partnum);
1905                 ical_conflicts(msgnum, partnum);
1906                 return;
1907         }
1908
1909         if (!strcasecmp(subcmd, "getics")) {
1910                 ical_getics();
1911                 return;
1912         }
1913
1914         if (!strcasecmp(subcmd, "putics")) {
1915                 ical_putics();
1916                 return;
1917         }
1918
1919         cprintf("%d Invalid subcommand\n", ERROR + CMD_NOT_SUPPORTED);
1920 }
1921
1922
1923
1924 /*
1925  * We don't know if the calendar room exists so we just create it at login
1926  */
1927 void ical_CtdlCreateRoom(void)
1928 {
1929         struct ctdlroom qr;
1930         visit vbuf;
1931
1932         /* Create the calendar room if it doesn't already exist */
1933         CtdlCreateRoom(USERCALENDARROOM, 4, "", 0, 1, 0, VIEW_CALENDAR);
1934
1935         /* Set expiration policy to manual; otherwise objects will be lost! */
1936         if (CtdlGetRoomLock(&qr, USERCALENDARROOM)) {
1937                 syslog(LOG_CRIT, "Couldn't get the user calendar room!\n");
1938                 return;
1939         }
1940         qr.QRep.expire_mode = EXPIRE_MANUAL;
1941         qr.QRdefaultview = VIEW_CALENDAR;       /* 3 = calendar view */
1942         CtdlPutRoomLock(&qr);
1943
1944         /* Set the view to a calendar view */
1945         CtdlGetRelationship(&vbuf, &CC->user, &qr);
1946         vbuf.v_view = VIEW_CALENDAR;
1947         CtdlSetRelationship(&vbuf, &CC->user, &qr);
1948
1949         /* Create the tasks list room if it doesn't already exist */
1950         CtdlCreateRoom(USERTASKSROOM, 4, "", 0, 1, 0, VIEW_TASKS);
1951
1952         /* Set expiration policy to manual; otherwise objects will be lost! */
1953         if (CtdlGetRoomLock(&qr, USERTASKSROOM)) {
1954                 syslog(LOG_CRIT, "Couldn't get the user calendar room!\n");
1955                 return;
1956         }
1957         qr.QRep.expire_mode = EXPIRE_MANUAL;
1958         qr.QRdefaultview = VIEW_TASKS;
1959         CtdlPutRoomLock(&qr);
1960
1961         /* Set the view to a task list view */
1962         CtdlGetRelationship(&vbuf, &CC->user, &qr);
1963         vbuf.v_view = VIEW_TASKS;
1964         CtdlSetRelationship(&vbuf, &CC->user, &qr);
1965
1966         /* Create the notes room if it doesn't already exist */
1967         CtdlCreateRoom(USERNOTESROOM, 4, "", 0, 1, 0, VIEW_NOTES);
1968
1969         /* Set expiration policy to manual; otherwise objects will be lost! */
1970         if (CtdlGetRoomLock(&qr, USERNOTESROOM)) {
1971                 syslog(LOG_CRIT, "Couldn't get the user calendar room!\n");
1972                 return;
1973         }
1974         qr.QRep.expire_mode = EXPIRE_MANUAL;
1975         qr.QRdefaultview = VIEW_NOTES;
1976         CtdlPutRoomLock(&qr);
1977
1978         /* Set the view to a notes view */
1979         CtdlGetRelationship(&vbuf, &CC->user, &qr);
1980         vbuf.v_view = VIEW_NOTES;
1981         CtdlSetRelationship(&vbuf, &CC->user, &qr);
1982
1983         return;
1984 }
1985
1986
1987 /*
1988  * ical_send_out_invitations() is called by ical_saving_vevent() when it finds a VEVENT.
1989  *
1990  * top_level_cal is the highest available level calendar object.
1991  * cal is the subcomponent containing the VEVENT.
1992  *
1993  * Note: if you change the encapsulation code here, change it in WebCit's ical_encapsulate_subcomponent()
1994  */
1995 void ical_send_out_invitations(icalcomponent *top_level_cal, icalcomponent *cal) {
1996         icalcomponent *the_request = NULL;
1997         char *serialized_request = NULL;
1998         icalcomponent *encaps = NULL;
1999         char *request_message_text = NULL;
2000         struct CtdlMessage *msg = NULL;
2001         struct recptypes *valid = NULL;
2002         char attendees_string[SIZ];
2003         int num_attendees = 0;
2004         char this_attendee[256];
2005         icalproperty *attendee = NULL;
2006         char summary_string[SIZ];
2007         icalproperty *summary = NULL;
2008         size_t reqsize;
2009         icalproperty *p;
2010         struct icaltimetype t;
2011         const icaltimezone *attached_zones[5] = { NULL, NULL, NULL, NULL, NULL };
2012         int i;
2013         const icaltimezone *z;
2014         int num_zones_attached = 0;
2015         int zone_already_attached;
2016         icalparameter *tzidp = NULL;
2017         const char *tzidc = NULL;
2018
2019         if (cal == NULL) {
2020                 syslog(LOG_ERR, "ERROR: trying to reply to NULL event?\n");
2021                 return;
2022         }
2023
2024
2025         /* If this is a VCALENDAR component, look for a VEVENT subcomponent. */
2026         if (icalcomponent_isa(cal) == ICAL_VCALENDAR_COMPONENT) {
2027                 ical_send_out_invitations(top_level_cal,
2028                         icalcomponent_get_first_component(
2029                                 cal, ICAL_VEVENT_COMPONENT
2030                         )
2031                 );
2032                 return;
2033         }
2034
2035         /* Clone the event */
2036         the_request = icalcomponent_new_clone(cal);
2037         if (the_request == NULL) {
2038                 syslog(LOG_ERR, "ERROR: cannot clone calendar object\n");
2039                 return;
2040         }
2041
2042         /* Extract the summary string -- we'll use it as the
2043          * message subject for the request
2044          */
2045         strcpy(summary_string, "Meeting request");
2046         summary = icalcomponent_get_first_property(the_request, ICAL_SUMMARY_PROPERTY);
2047         if (summary != NULL) {
2048                 if (icalproperty_get_summary(summary)) {
2049                         strcpy(summary_string,
2050                                 icalproperty_get_summary(summary) );
2051                 }
2052         }
2053
2054         /* Determine who the recipients of this message are (the attendees) */
2055         strcpy(attendees_string, "");
2056         for (attendee = icalcomponent_get_first_property(the_request, ICAL_ATTENDEE_PROPERTY); attendee != NULL; attendee = icalcomponent_get_next_property(the_request, ICAL_ATTENDEE_PROPERTY)) {
2057                 const char *ch = icalproperty_get_attendee(attendee);
2058                 if ((ch != NULL) && !strncasecmp(ch, "MAILTO:", 7)) {
2059                         safestrncpy(this_attendee, ch + 7, sizeof(this_attendee));
2060
2061                         if (!CtdlIsMe(this_attendee, sizeof this_attendee)) {   /* don't send an invitation to myself! */
2062                                 snprintf(&attendees_string[strlen(attendees_string)],
2063                                          sizeof(attendees_string) - strlen(attendees_string),
2064                                          "%s, ",
2065                                          this_attendee
2066                                         );
2067                                 ++num_attendees;
2068                         }
2069                 }
2070         }
2071
2072         syslog(LOG_DEBUG, "<%d> attendees: <%s>\n", num_attendees, attendees_string);
2073
2074         /* If there are no attendees, there are no invitations to send, so...
2075          * don't bother putting one together!  Punch out, Maverick!
2076          */
2077         if (num_attendees == 0) {
2078                 icalcomponent_free(the_request);
2079                 return;
2080         }
2081
2082         /* Encapsulate the VEVENT component into a complete VCALENDAR */
2083         encaps = icalcomponent_new_vcalendar();
2084         if (encaps == NULL) {
2085                 syslog(LOG_ALERT, "ERROR: could not allocate component!\n");
2086                 icalcomponent_free(the_request);
2087                 return;
2088         }
2089
2090         /* Set the Product ID */
2091         icalcomponent_add_property(encaps, icalproperty_new_prodid(PRODID));
2092
2093         /* Set the Version Number */
2094         icalcomponent_add_property(encaps, icalproperty_new_version("2.0"));
2095
2096         /* Set the method to REQUEST */
2097         icalcomponent_set_method(encaps, ICAL_METHOD_REQUEST);
2098
2099         /* Look for properties containing timezone parameters, to see if we need to attach VTIMEZONEs */
2100         for (p = icalcomponent_get_first_property(the_request, ICAL_ANY_PROPERTY);
2101              p != NULL;
2102              p = icalcomponent_get_next_property(the_request, ICAL_ANY_PROPERTY))
2103         {
2104                 if ( (icalproperty_isa(p) == ICAL_COMPLETED_PROPERTY)
2105                   || (icalproperty_isa(p) == ICAL_CREATED_PROPERTY)
2106                   || (icalproperty_isa(p) == ICAL_DATEMAX_PROPERTY)
2107                   || (icalproperty_isa(p) == ICAL_DATEMIN_PROPERTY)
2108                   || (icalproperty_isa(p) == ICAL_DTEND_PROPERTY)
2109                   || (icalproperty_isa(p) == ICAL_DTSTAMP_PROPERTY)
2110                   || (icalproperty_isa(p) == ICAL_DTSTART_PROPERTY)
2111                   || (icalproperty_isa(p) == ICAL_DUE_PROPERTY)
2112                   || (icalproperty_isa(p) == ICAL_EXDATE_PROPERTY)
2113                   || (icalproperty_isa(p) == ICAL_LASTMODIFIED_PROPERTY)
2114                   || (icalproperty_isa(p) == ICAL_MAXDATE_PROPERTY)
2115                   || (icalproperty_isa(p) == ICAL_MINDATE_PROPERTY)
2116                   || (icalproperty_isa(p) == ICAL_RECURRENCEID_PROPERTY)
2117                 ) {
2118                         t = icalproperty_get_dtstart(p);        // it's safe to use dtstart for all of them
2119
2120                         /* Determine the tzid in order for some of the conditions below to work */
2121                         tzidp = icalproperty_get_first_parameter(p, ICAL_TZID_PARAMETER);
2122                         if (tzidp) {
2123                                 tzidc = icalparameter_get_tzid(tzidp);
2124                         }
2125                         else {
2126                                 tzidc = NULL;
2127                         }
2128
2129                         /* First see if there's a timezone attached to the data structure itself */
2130                         if (icaltime_is_utc(t)) {
2131                                 z = icaltimezone_get_utc_timezone();
2132                         }
2133                         else {
2134                                 z = icaltime_get_timezone(t);
2135                         }
2136
2137                         /* If not, try to determine the tzid from the parameter using attached zones */
2138                         if ((!z) && (tzidc)) {
2139                                 z = icalcomponent_get_timezone(top_level_cal, tzidc);
2140                         }
2141
2142                         /* Still no good?  Try our internal database */
2143                         if ((!z) && (tzidc)) {
2144                                 z = icaltimezone_get_builtin_timezone_from_tzid(tzidc);
2145                         }
2146
2147                         if (z) {
2148                                 /* We have a valid timezone.  Good.  Now we need to attach it. */
2149
2150                                 zone_already_attached = 0;
2151                                 for (i=0; i<5; ++i) {
2152                                         if (z == attached_zones[i]) {
2153                                                 /* We've already got this one, no need to attach another. */
2154                                                 ++zone_already_attached;
2155                                         }
2156                                 }
2157                                 if ((!zone_already_attached) && (num_zones_attached < 5)) {
2158                                         /* This is a new one, so attach it. */
2159                                         attached_zones[num_zones_attached++] = z;
2160                                 }
2161
2162                                 icalproperty_set_parameter(p,
2163                                         icalparameter_new_tzid(icaltimezone_get_tzid(z))
2164                                 );
2165                         }
2166                 }
2167         }
2168
2169         /* Encapsulate any timezones we need */
2170         if (num_zones_attached > 0) for (i=0; i<num_zones_attached; ++i) {
2171                 icalcomponent *zc;
2172                 zc = icalcomponent_new_clone(icaltimezone_get_component(attached_zones[i]));
2173                 icalcomponent_add_component(encaps, zc);
2174         }
2175
2176         /* Here we go: encapsulate the VEVENT into the VCALENDAR.  We now no longer
2177          * are responsible for "the_request"'s memory -- it will be freed
2178          * when we free "encaps".
2179          */
2180         icalcomponent_add_component(encaps, the_request);
2181
2182         /* Serialize it */
2183         serialized_request = icalcomponent_as_ical_string_r(encaps);
2184         icalcomponent_free(encaps);     /* Don't need this anymore. */
2185         if (serialized_request == NULL) return;
2186
2187         reqsize = strlen(serialized_request) + SIZ;
2188         request_message_text = malloc(reqsize);
2189         if (request_message_text != NULL) {
2190                 snprintf(request_message_text, reqsize,
2191                         "Content-type: text/calendar\r\n\r\n%s\r\n",
2192                         serialized_request
2193                 );
2194
2195                 msg = CtdlMakeMessage(
2196                         &CC->user,
2197                         NULL,                   /* No single recipient here */
2198                         NULL,                   /* No single recipient here */
2199                         CC->room.QRname,
2200                         0,
2201                         FMT_RFC822,
2202                         NULL,
2203                         NULL,
2204                         summary_string,         /* Use summary for subject */
2205                         NULL,
2206                         request_message_text,
2207                         NULL
2208                 );
2209
2210                 if (msg != NULL) {
2211                         valid = validate_recipients(attendees_string, NULL, 0);
2212                         CtdlSubmitMsg(msg, valid, "", QP_EADDR);
2213                         CtdlFreeMessage(msg);
2214                         free_recipients(valid);
2215                 }
2216         }
2217         free(serialized_request);
2218 }
2219
2220
2221 /*
2222  * When a calendar object is being saved, determine whether it's a VEVENT
2223  * and the user saving it is the organizer.  If so, send out invitations
2224  * to any listed attendees.
2225  *
2226  * This function is recursive.  The caller can simply supply the same object
2227  * as both arguments.  When it recurses it will alter the second argument
2228  * while holding on to the top level object.  This allows us to go back and
2229  * grab things like time zones which might be attached.
2230  *
2231  */
2232 void ical_saving_vevent(icalcomponent *top_level_cal, icalcomponent *cal) {
2233         icalcomponent *c;
2234         icalproperty *organizer = NULL;
2235         char organizer_string[SIZ];
2236
2237         syslog(LOG_DEBUG, "ical_saving_vevent() has been called!\n");
2238
2239         /* Don't send out invitations unless the client wants us to. */
2240         if (CIT_ICAL->server_generated_invitations == 0) {
2241                 return;
2242         }
2243
2244         /* Don't send out invitations if we've been asked not to. */
2245         if (CIT_ICAL->avoid_sending_invitations > 0) {
2246                 return;
2247         }
2248
2249         strcpy(organizer_string, "");
2250         /*
2251          * The VEVENT subcomponent is the one we're interested in.
2252          * Send out invitations if, and only if, this user is the Organizer.
2253          */
2254         if (icalcomponent_isa(cal) == ICAL_VEVENT_COMPONENT) {
2255                 organizer = icalcomponent_get_first_property(cal, ICAL_ORGANIZER_PROPERTY);
2256                 if (organizer != NULL) {
2257                         if (icalproperty_get_organizer(organizer)) {
2258                                 strcpy(organizer_string,
2259                                         icalproperty_get_organizer(organizer));
2260                         }
2261                 }
2262                 if (!strncasecmp(organizer_string, "MAILTO:", 7)) {
2263                         strcpy(organizer_string, &organizer_string[7]);
2264                         striplt(organizer_string);
2265                         /*
2266                          * If the user saving the event is listed as the
2267                          * organizer, then send out invitations.
2268                          */
2269                         if (CtdlIsMe(organizer_string, sizeof organizer_string)) {
2270                                 ical_send_out_invitations(top_level_cal, cal);
2271                         }
2272                 }
2273         }
2274
2275         /* If the component has subcomponents, recurse through them. */
2276         for (c = icalcomponent_get_first_component(cal, ICAL_ANY_COMPONENT);
2277             (c != NULL);
2278             c = icalcomponent_get_next_component(cal, ICAL_ANY_COMPONENT)) {
2279                 /* Recursively process subcomponent */
2280                 ical_saving_vevent(top_level_cal, c);
2281         }
2282
2283 }
2284
2285
2286
2287 /*
2288  * Back end for ical_obj_beforesave()
2289  * This hunts for the UID of the calendar event (becomes Citadel msg EUID),
2290  * the summary of the event (becomes message subject),
2291  * and the start time (becomes message date/time).
2292  */
2293 void ical_obj_beforesave_backend(char *name, char *filename, char *partnum,
2294                 char *disp, void *content, char *cbtype, char *cbcharset, size_t length,
2295                 char *encoding, char *cbid, void *cbuserdata)
2296 {
2297         const char* pch;
2298         icalcomponent *cal, *nested_event, *nested_todo, *whole_cal;
2299         icalproperty *p;
2300         char new_uid[256] = "";
2301         struct CtdlMessage *msg = (struct CtdlMessage *) cbuserdata;
2302
2303         if (!msg) return;
2304
2305         /* We're only interested in calendar data. */
2306         if (  (strcasecmp(cbtype, "text/calendar"))
2307            && (strcasecmp(cbtype, "application/ics")) ) {
2308                 return;
2309         }
2310
2311         /* Hunt for the UID and drop it in
2312          * the "user data" pointer for the MIME parser.  When
2313          * ical_obj_beforesave() sees it there, it'll set the Exclusive msgid
2314          * to that string.
2315          */
2316         whole_cal = icalcomponent_new_from_string(content);
2317         cal = whole_cal;
2318         if (cal != NULL) {
2319                 if (icalcomponent_isa(cal) == ICAL_VCALENDAR_COMPONENT) {
2320                         nested_event = icalcomponent_get_first_component(
2321                                 cal, ICAL_VEVENT_COMPONENT);
2322                         if (nested_event != NULL) {
2323                                 cal = nested_event;
2324                         }
2325                         else {
2326                                 nested_todo = icalcomponent_get_first_component(
2327                                         cal, ICAL_VTODO_COMPONENT);
2328                                 if (nested_todo != NULL) {
2329                                         cal = nested_todo;
2330                                 }
2331                         }
2332                 }
2333
2334                 if (cal != NULL) {
2335
2336                         /* Set the message EUID to the iCalendar UID */
2337
2338                         p = ical_ctdl_get_subprop(cal, ICAL_UID_PROPERTY);
2339                         if (p == NULL) {
2340                                 /* If there's no uid we must generate one */
2341                                 generate_uuid(new_uid);
2342                                 icalcomponent_add_property(cal, icalproperty_new_uid(new_uid));
2343                                 p = ical_ctdl_get_subprop(cal, ICAL_UID_PROPERTY);
2344                         }
2345                         if (p != NULL) {
2346                                 pch = icalproperty_get_comment(p);
2347                                 if (!IsEmptyStr(pch)) {
2348                                         CM_SetField(msg, eExclusiveID, pch, strlen(pch));
2349                                         syslog(LOG_DEBUG, "Saving calendar UID <%s>\n", pch);
2350                                 }
2351                         }
2352
2353                         /* Set the message subject to the iCalendar summary */
2354
2355                         p = ical_ctdl_get_subprop(cal, ICAL_SUMMARY_PROPERTY);
2356                         if (p != NULL) {
2357                                 pch = icalproperty_get_comment(p);
2358                                 if (!IsEmptyStr(pch)) {
2359                                         char *subj;
2360
2361                                         subj = rfc2047encode(pch, strlen(pch));
2362                                         CM_SetAsField(msg, eMsgSubject, &subj, strlen(subj));
2363                                 }
2364                         }
2365
2366                         /* Set the message date/time to the iCalendar start time */
2367
2368                         p = ical_ctdl_get_subprop(cal, ICAL_DTSTART_PROPERTY);
2369                         if (p != NULL) {
2370                                 time_t idtstart;
2371                                 idtstart = icaltime_as_timet(icalproperty_get_dtstart(p));
2372                                 if (idtstart > 0) {
2373                                         CM_SetFieldLONG(msg, eTimestamp, idtstart);
2374                                 }
2375                         }
2376
2377                 }
2378                 icalcomponent_free(cal);
2379                 if (whole_cal != cal) {
2380                         icalcomponent_free(whole_cal);
2381                 }
2382         }
2383 }
2384
2385
2386
2387
2388 /*
2389  * See if we need to prevent the object from being saved (we don't allow
2390  * MIME types other than text/calendar in "calendar" or "tasks" rooms).
2391  *
2392  * If the message is being saved, we also set various message header fields
2393  * using data found in the iCalendar object.
2394  */
2395 int ical_obj_beforesave(struct CtdlMessage *msg)
2396 {
2397         /* First determine if this is a calendar or tasks room */
2398         if (  (CC->room.QRdefaultview != VIEW_CALENDAR)
2399            && (CC->room.QRdefaultview != VIEW_TASKS)
2400         ) {
2401                 return(0);              /* Not an iCalendar-centric room */
2402         }
2403
2404         /* It must be an RFC822 message! */
2405         if (msg->cm_format_type != 4) {
2406                 syslog(LOG_DEBUG, "Rejecting non-RFC822 message\n");
2407                 return(1);              /* You tried to save a non-RFC822 message! */
2408         }
2409
2410         if (CM_IsEmpty(msg, eMesageText)) {
2411                 return(1);              /* You tried to save a null message! */
2412         }
2413
2414         /* Do all of our lovely back-end parsing */
2415         mime_parser(msg->cm_fields[eMesageText],
2416                 NULL,
2417                 *ical_obj_beforesave_backend,
2418                 NULL, NULL,
2419                 (void *)msg,
2420                 0
2421         );
2422
2423         return(0);
2424 }
2425
2426
2427 /*
2428  * Things we need to do after saving a calendar event.
2429  */
2430 void ical_obj_aftersave_backend(char *name, char *filename, char *partnum,
2431                 char *disp, void *content, char *cbtype, char *cbcharset, size_t length,
2432                 char *encoding, char *cbid, void *cbuserdata)
2433 {
2434         icalcomponent *cal;
2435
2436         /* We're only interested in calendar items here. */
2437         if (  (strcasecmp(cbtype, "text/calendar"))
2438            && (strcasecmp(cbtype, "application/ics")) ) {
2439                 return;
2440         }
2441
2442         /* Hunt for the UID and drop it in
2443          * the "user data" pointer for the MIME parser.  When
2444          * ical_obj_beforesave() sees it there, it'll set the Exclusive msgid
2445          * to that string.
2446          */
2447         if (  (!strcasecmp(cbtype, "text/calendar"))
2448            || (!strcasecmp(cbtype, "application/ics")) ) {
2449                 cal = icalcomponent_new_from_string(content);
2450                 if (cal != NULL) {
2451                         ical_saving_vevent(cal, cal);
2452                         icalcomponent_free(cal);
2453                 }
2454         }
2455 }
2456
2457
2458 /*
2459  * Things we need to do after saving a calendar event.
2460  * (This will start back end tasks such as automatic generation of invitations,
2461  * if such actions are appropriate.)
2462  */
2463 int ical_obj_aftersave(struct CtdlMessage *msg)
2464 {
2465         char roomname[ROOMNAMELEN];
2466
2467         /*
2468          * If this isn't the Calendar> room, no further action is necessary.
2469          */
2470
2471         /* First determine if this is our room */
2472         CtdlMailboxName(roomname, sizeof roomname, &CC->user, USERCALENDARROOM);
2473         if (strcasecmp(roomname, CC->room.QRname)) {
2474                 return(0);      /* Not the Calendar room -- don't do anything. */
2475         }
2476
2477         /* It must be an RFC822 message! */
2478         if (msg->cm_format_type != 4) return(1);
2479
2480         /* Reject null messages */
2481         if (CM_IsEmpty(msg, eMesageText)) return(1);
2482
2483         /* Now recurse through it looking for our icalendar data */
2484         mime_parser(msg->cm_fields[eMesageText],
2485                 NULL,
2486                 *ical_obj_aftersave_backend,
2487                 NULL, NULL,
2488                 NULL,
2489                 0
2490         );
2491
2492         return(0);
2493 }
2494
2495
2496 void ical_session_startup(void) {
2497         CIT_ICAL = malloc(sizeof(struct cit_ical));
2498         memset(CIT_ICAL, 0, sizeof(struct cit_ical));
2499 }
2500
2501 void ical_session_shutdown(void) {
2502         free(CIT_ICAL);
2503 }
2504
2505
2506 /*
2507  * Back end for ical_fixed_output()
2508  */
2509 void ical_fixed_output_backend(icalcomponent *cal,
2510                         int recursion_level
2511 ) {
2512         icalcomponent *c;
2513         icalproperty *p;
2514         char buf[256];
2515         const char *ch;
2516
2517         p = icalcomponent_get_first_property(cal, ICAL_SUMMARY_PROPERTY);
2518         if (p != NULL) {
2519                 cprintf("%s\n", (const char *)icalproperty_get_comment(p));
2520         }
2521
2522         p = icalcomponent_get_first_property(cal, ICAL_LOCATION_PROPERTY);
2523         if (p != NULL) {
2524                 cprintf("%s\n", (const char *)icalproperty_get_comment(p));
2525         }
2526
2527         p = icalcomponent_get_first_property(cal, ICAL_DESCRIPTION_PROPERTY);
2528         if (p != NULL) {
2529                 cprintf("%s\n", (const char *)icalproperty_get_comment(p));
2530         }
2531
2532         /* If the component has attendees, iterate through them. */
2533         for (p = icalcomponent_get_first_property(cal, ICAL_ATTENDEE_PROPERTY); (p != NULL); p = icalcomponent_get_next_property(cal, ICAL_ATTENDEE_PROPERTY)) {
2534                 ch =  icalproperty_get_attendee(p);
2535                 if ((ch != NULL) &&
2536                     !strncasecmp(ch, "MAILTO:", 7)) {
2537
2538                         /* screen name or email address */
2539                         safestrncpy(buf, ch + 7, sizeof(buf));
2540                         striplt(buf);
2541                         cprintf("%s ", buf);
2542                 }
2543                 cprintf("\n");
2544         }
2545
2546         /* If the component has subcomponents, recurse through them. */
2547         for (c = icalcomponent_get_first_component(cal, ICAL_ANY_COMPONENT);
2548             (c != 0);
2549             c = icalcomponent_get_next_component(cal, ICAL_ANY_COMPONENT)) {
2550                 /* Recursively process subcomponent */
2551                 ical_fixed_output_backend(c, recursion_level+1);
2552         }
2553 }
2554
2555
2556
2557 /*
2558  * Function to output iCalendar data as plain text.  Nobody uses MSG0
2559  * anymore, so really this is just so we expose the vCard data to the full
2560  * text indexer.
2561  */
2562 void ical_fixed_output(char *ptr, int len) {
2563         icalcomponent *cal;
2564         char *stringy_cal;
2565
2566         stringy_cal = malloc(len + 1);
2567         safestrncpy(stringy_cal, ptr, len + 1);
2568         cal = icalcomponent_new_from_string(stringy_cal);
2569         free(stringy_cal);
2570
2571         if (cal == NULL) {
2572                 return;
2573         }
2574
2575         ical_fixed_output_backend(cal, 0);
2576
2577         /* Free the memory we obtained from libical's constructor */
2578         icalcomponent_free(cal);
2579 }
2580
2581
2582
2583 void serv_calendar_destroy(void)
2584 {
2585         icaltimezone_free_builtin_timezones();
2586 }
2587
2588 /*
2589  * Register this module with the Citadel server.
2590  */
2591 CTDL_MODULE_INIT(calendar)
2592 {
2593         if (!threading)
2594         {
2595
2596                 /* Tell libical to return errors instead of aborting if it gets bad data */
2597                 icalerror_errors_are_fatal = 0;
2598
2599                 /* Use our own application prefix in tzid's generated from system tzdata */
2600                 icaltimezone_set_tzid_prefix("/citadel.org/");
2601
2602                 /* Initialize our hook functions */
2603                 CtdlRegisterMessageHook(ical_obj_beforesave, EVT_BEFORESAVE);
2604                 CtdlRegisterMessageHook(ical_obj_aftersave, EVT_AFTERSAVE);
2605                 CtdlRegisterSessionHook(ical_CtdlCreateRoom, EVT_LOGIN, PRIO_LOGIN + 1);
2606                 CtdlRegisterProtoHook(cmd_ical, "ICAL", "Citadel iCal commands");
2607                 CtdlRegisterSessionHook(ical_session_startup, EVT_START, PRIO_START + 1);
2608                 CtdlRegisterSessionHook(ical_session_shutdown, EVT_STOP, PRIO_STOP + 80);
2609                 CtdlRegisterFixedOutputHook("text/calendar", ical_fixed_output);
2610                 CtdlRegisterFixedOutputHook("application/ics", ical_fixed_output);
2611                 CtdlRegisterCleanupHook(serv_calendar_destroy);
2612         }
2613
2614         /* return our module name for the log */
2615         return "calendar";
2616 }