webcit/calendar.c

   1 /*
   2  * $Id$
   3  *
   4  * Functions which handle calendar objects and their processing/display.
   5  *
   6  */
   7
   8 #include <ctype.h>
   9 #include <stdlib.h>
  10 #include <unistd.h>
  11 #include <stdio.h>
  12 #include <fcntl.h>
  13 #include <signal.h>
  14 #include <sys/types.h>
  15 #include <sys/wait.h>
  16 #include <sys/socket.h>
  17 #include <limits.h>
  18 #include <netinet/in.h>
  19 #include <netdb.h>
  20 #include <string.h>
  21 #include <pwd.h>
  22 #include <errno.h>
  23 #include <stdarg.h>
  24 #include <pthread.h>
  25 #include <signal.h>
  26 #include "webcit.h"
  27 #include "webserver.h"
  28
  29 #ifdef HAVE_ICAL_H
  30 #include <ical.h>
  31 #endif
  32
  33
  34 #ifndef HAVE_ICAL_H
  35
  36 /*
  37  * Handler stubs for builds with no calendar library available
  38  */
  39 void cal_process_attachment(char *part_source) {
  40
  41         wprintf("<I>This message contains calendaring/scheduling information,"
  42                 " but support for calendars is not available on this "
  43                 "particular system.  Please ask your system administrator to "
  44                 "install a new version of the Citadel web service with "
  45                 "calendaring enabled.</I><BR>\n"
  46         );
  47
  48 }
  49
  50 void display_calendar(long msgnum) {
  51         wprintf("<i>Cannot display calendar item</i><br>\n");
  52 }
  53
  54 void display_task(long msgnum) {
  55         wprintf("<i>Cannot display item from task list</i><br>\n");
  56 }
  57
  58 #else /* HAVE_ICAL_H */
  59
  60
  61
  62 /*
  63  * Process a single calendar component.
  64  * It won't be a compound component at this point because those have
  65  * already been broken down by cal_process_object().
  66  */
  67 void cal_process_subcomponent(icalcomponent *cal) {
  68         wprintf("cal_process_subcomponent() called<BR>\n");
  69         wprintf("cal_process_subcomponent() exiting<BR>\n");
  70 }
  71
  72
  73
  74
  75
  76 /*
  77  * Process a calendar object
  78  * ...at this point it's already been deserialized by cal_process_attachment()
  79  */
  80 void cal_process_object(icalcomponent *cal) {
  81         icalcomponent *c;
  82         int num_subcomponents = 0;
  83
  84         wprintf("cal_process_object() called<BR>\n");
  85
  86         /* Iterate through all subcomponents */
  87         wprintf("Iterating through all sub-components<BR>\n");
  88         for (c = icalcomponent_get_first_component(cal, ICAL_ANY_COMPONENT);
  89             (c != 0);
  90             c = icalcomponent_get_next_component(cal, ICAL_ANY_COMPONENT)) {
  91                 cal_process_subcomponent(c);
  92                 ++num_subcomponents;
  93         }
  94
  95         /* Iterate through all subcomponents */
  96         wprintf("Iterating through VEVENTs<BR>\n");
  97         for (c = icalcomponent_get_first_component(cal, ICAL_VEVENT_COMPONENT);
  98             (c != 0);
  99             c = icalcomponent_get_next_component(cal, ICAL_VEVENT_COMPONENT)) {
 100                 cal_process_subcomponent(c);
 101                 --num_subcomponents;
 102         }
 103
 104         /* Iterate through all subcomponents */
 105         wprintf("Iterating through VTODOs<BR>\n");
 106         for (c = icalcomponent_get_first_component(cal, ICAL_VTODO_COMPONENT);
 107             (c != 0);
 108             c = icalcomponent_get_next_component(cal, ICAL_VTODO_COMPONENT)) {
 109                 cal_process_subcomponent(c);
 110                 --num_subcomponents;
 111         }
 112
 113         /* Iterate through all subcomponents */
 114         wprintf("Iterating through VJOURNALs<BR>\n");
 115         for (c = icalcomponent_get_first_component(cal, ICAL_VJOURNAL_COMPONENT);
 116             (c != 0);
 117             c = icalcomponent_get_next_component(cal, ICAL_VJOURNAL_COMPONENT)) {
 118                 cal_process_subcomponent(c);
 119                 --num_subcomponents;
 120         }
 121
 122         /* Iterate through all subcomponents */
 123         wprintf("Iterating through VCALENDARs<BR>\n");
 124         for (c = icalcomponent_get_first_component(cal, ICAL_VCALENDAR_COMPONENT);
 125             (c != 0);
 126             c = icalcomponent_get_next_component(cal, ICAL_VCALENDAR_COMPONENT)) {
 127                 cal_process_subcomponent(c);
 128                 --num_subcomponents;
 129         }
 130
 131         /* Iterate through all subcomponents */
 132         wprintf("Iterating through VFREEBUSYs<BR>\n");
 133         for (c = icalcomponent_get_first_component(cal, ICAL_VFREEBUSY_COMPONENT);
 134             (c != 0);
 135             c = icalcomponent_get_next_component(cal, ICAL_VFREEBUSY_COMPONENT)) {
 136                 cal_process_subcomponent(c);
 137                 --num_subcomponents;
 138         }
 139
 140         /* Iterate through all subcomponents */
 141         wprintf("Iterating through VALARMs<BR>\n");
 142         for (c = icalcomponent_get_first_component(cal, ICAL_VALARM_COMPONENT);
 143             (c != 0);
 144             c = icalcomponent_get_next_component(cal, ICAL_VALARM_COMPONENT)) {
 145                 cal_process_subcomponent(c);
 146                 --num_subcomponents;
 147         }
 148
 149         /* Iterate through all subcomponents */
 150         wprintf("Iterating through VTIMEZONEs<BR>\n");
 151         for (c = icalcomponent_get_first_component(cal, ICAL_VTIMEZONE_COMPONENT);
 152             (c != 0);
 153             c = icalcomponent_get_next_component(cal, ICAL_VTIMEZONE_COMPONENT)) {
 154                 cal_process_subcomponent(c);
 155                 --num_subcomponents;
 156         }
 157
 158         /* Iterate through all subcomponents */
 159         wprintf("Iterating through VSCHEDULEs<BR>\n");
 160         for (c = icalcomponent_get_first_component(cal, ICAL_VSCHEDULE_COMPONENT);
 161             (c != 0);
 162             c = icalcomponent_get_next_component(cal, ICAL_VSCHEDULE_COMPONENT)) {
 163                 cal_process_subcomponent(c);
 164                 --num_subcomponents;
 165         }
 166
 167         /* Iterate through all subcomponents */
 168         wprintf("Iterating through VQUERYs<BR>\n");
 169         for (c = icalcomponent_get_first_component(cal, ICAL_VQUERY_COMPONENT);
 170             (c != 0);
 171             c = icalcomponent_get_next_component(cal, ICAL_VQUERY_COMPONENT)) {
 172                 cal_process_subcomponent(c);
 173                 --num_subcomponents;
 174         }
 175
 176         /* Iterate through all subcomponents */
 177         wprintf("Iterating through VCARs<BR>\n");
 178         for (c = icalcomponent_get_first_component(cal, ICAL_VCAR_COMPONENT);
 179             (c != 0);
 180             c = icalcomponent_get_next_component(cal, ICAL_VCAR_COMPONENT)) {
 181                 cal_process_subcomponent(c);
 182                 --num_subcomponents;
 183         }
 184
 185         /* Iterate through all subcomponents */
 186         wprintf("Iterating through VCOMMANDs<BR>\n");
 187         for (c = icalcomponent_get_first_component(cal, ICAL_VCOMMAND_COMPONENT);
 188             (c != 0);
 189             c = icalcomponent_get_next_component(cal, ICAL_VCOMMAND_COMPONENT)) {
 190                 cal_process_subcomponent(c);
 191                 --num_subcomponents;
 192         }
 193
 194         if (num_subcomponents != 0) {
 195                 wprintf("Warning: %d subcomponents unhandled<BR>\n",
 196                         num_subcomponents);
 197         }
 198
 199         wprintf("cal_process_object() exiting<BR>\n");
 200 }
 201
 202
 203 /*
 204  * Deserialize a calendar object in a message so it can be processed.
 205  * (This is the main entry point for these things)
 206  */
 207 void cal_process_attachment(char *part_source) {
 208         icalcomponent *cal;
 209
 210         wprintf("Processing calendar attachment<BR>\n");
 211         cal = icalcomponent_new_from_string(part_source);
 212
 213         if (cal == NULL) {
 214                 wprintf("Error parsing calendar object: %s<BR>\n",
 215                         icalerror_strerror(icalerrno));
 216                 return;
 217         }
 218
 219         cal_process_object(cal);
 220
 221         /* Free the memory we obtained from libical's constructor */
 222         icalcomponent_free(cal);
 223 }
 224
 225
 226 /*
 227  * Display handlers for message reading
 228  */
 229
 230 void display_individual_task(char *task_source) {
 231         wprintf("doing display_individual_task()<BR>\n");
 232 }
 233
 234 void display_individual_cal(char *task_source) {
 235         wprintf("doing display_individual_task()<BR>\n");
 236 }
 237
 238
 239 /*
 240  * Code common to all display handlers.  Given a message number and a MIME
 241  * type, we load the message and hunt for that MIME type.  If found, we load
 242  * the relevant part and feed it to the specified handler.
 243  */
 244 void display_using_handler(long msgnum,
 245                         char *mimetype,
 246                         void (*callback)(char *)
 247         ) {
 248         char buf[SIZ];
 249         char mime_partnum[SIZ];
 250         char mime_filename[SIZ];
 251         char mime_content_type[SIZ];
 252         char mime_disposition[SIZ];
 253         int mime_length;
 254         char relevant_partnum[SIZ];
 255         char *relevant_source = NULL;
 256
 257         struct {
 258                 char date[SIZ];
 259                 char from[SIZ];
 260                 char to[SIZ];
 261                 char subj[SIZ];
 262                 int hasattachments;
 263         } summ;
 264
 265         memset(&summ, 0, sizeof(summ));
 266         strcpy(summ.subj, "(no subject)");
 267
 268         sprintf(buf, "MSG0 %ld|1", msgnum);     /* ask for headers only */
 269         serv_puts(buf);
 270         serv_gets(buf);
 271         if (buf[0] != '1') return;
 272
 273         while (serv_gets(buf), strcmp(buf, "000")) {
 274                 if (!strncasecmp(buf, "part=", 5)) {
 275                         extract(mime_filename, &buf[5], 1);
 276                         extract(mime_partnum, &buf[5], 2);
 277                         extract(mime_disposition, &buf[5], 3);
 278                         extract(mime_content_type, &buf[5], 4);
 279                         mime_length = extract_int(&buf[5], 5);
 280
 281                         if (!strcasecmp(mime_content_type, "text/calendar")) {
 282                                 strcpy(relevant_partnum, mime_partnum);
 283                         }
 284
 285                 }
 286         }
 287
 288         if (strlen(relevant_partnum) > 0) {
 289                 relevant_source = load_mimepart(msgnum, relevant_partnum);
 290                 if (relevant_source != NULL) {
 291
 292                         /* Display the task */
 293                         display_individual_task(relevant_source);
 294                         free(relevant_source);
 295                 }
 296         }
 297
 298 }
 299
 300 void display_task(long msgnum) {
 301         display_using_handler(msgnum, "text/calendar", display_individual_task);
 302 }
 303
 304 void display_calendar(long msgnum) {
 305         display_using_handler(msgnum, "text/calendar", display_individual_cal);
 306 }
 307
 308 #endif /* HAVE_ICAL_H */