src/plugins/vcalendar/vcal_manager.c

   1 /*
   2  * Claws Mail -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2007 Colin Leroy <colin@colino.net> and
   4  * the Claws Mail team
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19  */
  20
  21 #ifdef HAVE_CONFIG_H
  22 #  include "config.h"
  23 #include "claws-features.h"
  24 #endif
  25
  26 #include <stddef.h>
  27 #include <glib.h>
  28 #include <glib/gi18n.h>
  29
  30 #include <sys/types.h>
  31 #include <sys/stat.h>
  32 #ifdef USE_PTHREAD
  33 #include <pthread.h>
  34 #endif
  35 #include <ical.h>
  36 #include "vcalendar.h"
  37 #include "vcal_folder.h"
  38 #include "vcal_manager.h"
  39 #include "vcal_meeting_gtk.h"
  40 #include "vcal_prefs.h"
  41 #include "xml.h"
  42 #include "xmlprops.h"
  43 #include "prefs.h"
  44 #include "prefs_common.h"
  45 #include "prefs_account.h"
  46 #include "alertpanel.h"
  47 #include "account.h"
  48 #include "codeconv.h"
  49 #include <time.h>
  50 #include "folder.h"
  51 #include "quoted-printable.h"
  52 #include "utils.h"
  53
  54 #ifdef G_OS_WIN32
  55 #define getuid() 0
  56 #endif
  57
  58 Answer *answer_new(const gchar *attendee,
  59                           const gchar *name,
  60                           enum icalparameter_partstat ans,
  61                           enum icalparameter_cutype cutype)
  62 {
  63         Answer *answer = g_new0(Answer, 1);
  64         answer->attendee = g_strdup(attendee);
  65         answer->name = g_strdup(name);
  66         if (!answer->name)
  67                 answer->name = g_strdup("");
  68         if (!answer->attendee)
  69                 answer->attendee = g_strdup("");
  70         answer->answer = ans;
  71         answer->cutype = cutype;
  72         return answer;
  73 }
  74
  75 static void answer_free(Answer *answer)
  76 {
  77         g_free(answer->attendee);
  78         g_free(answer->name);
  79         g_free(answer);
  80 }
  81
  82 static GSList *answer_find(VCalEvent *event, Answer *answer)
  83 {
  84         GSList *cur = event->answers;
  85         while (cur && cur->data) {
  86                 Answer *b = (Answer *)cur->data;
  87                 if (!strcasecmp(b->attendee, answer->attendee))
  88                         return cur;
  89                 cur = cur->next;
  90         }
  91         return NULL;
  92 }
  93
  94 void vcal_manager_copy_attendees(VCalEvent *src, VCalEvent *dest)
  95 {
  96         GSList *cur = src->answers;
  97         while (cur && cur->data) {
  98                 Answer *a = (Answer *)cur->data;
  99                 Answer *b = answer_new(a->attendee, a->name, a->answer, a->cutype);
 100                 dest->answers = g_slist_prepend(dest->answers, b);
 101                 cur = cur->next;
 102         }
 103         dest->answers = g_slist_reverse(dest->answers);
 104 }
 105
 106 gchar *vcal_manager_answer_get_text(enum icalparameter_partstat ans)
 107 {
 108         static gchar *replies[5]={
 109                 N_("accepted"),
 110                 N_("tentatively accepted"),
 111                 N_("declined"),
 112                 N_("did not answer"),
 113                 N_("unknown")
 114         };
 115
 116         switch (ans) {
 117         case ICAL_PARTSTAT_ACCEPTED:
 118                 return _(replies[0]);
 119                 break;
 120         case ICAL_PARTSTAT_DECLINED:
 121                 return _(replies[2]);
 122                 break;
 123         case ICAL_PARTSTAT_TENTATIVE:
 124                 return _(replies[1]);
 125                 break;
 126         case ICAL_PARTSTAT_NEEDSACTION:
 127                 return _(replies[3]);
 128         case ICAL_PARTSTAT_DELEGATED:
 129         case ICAL_PARTSTAT_COMPLETED:
 130         case ICAL_PARTSTAT_X:
 131         case ICAL_PARTSTAT_INPROCESS:
 132         case ICAL_PARTSTAT_NONE:
 133                 return _(replies[4]);
 134                 break;
 135         }
 136         return NULL;
 137 }
 138
 139 gchar *vcal_manager_cutype_get_text(enum icalparameter_cutype type)
 140 {
 141         static gchar *replies[5]={
 142                 N_("individual"),
 143                 N_("group"),
 144                 N_("resource"),
 145                 N_("room"),
 146                 N_("unknown")
 147         };
 148
 149         switch (type) {
 150         case ICAL_CUTYPE_INDIVIDUAL:
 151                 return _(replies[0]);
 152                 break;
 153         case ICAL_CUTYPE_GROUP:
 154                 return _(replies[1]);
 155                 break;
 156         case ICAL_CUTYPE_RESOURCE:
 157                 return _(replies[2]);
 158                 break;
 159         case ICAL_CUTYPE_ROOM:
 160                 return _(replies[3]);
 161         default:
 162                 return _(replies[4]);
 163                 break;
 164         }
 165         return NULL;
 166 }
 167
 168 static GSList *answer_remove(VCalEvent *event, Answer *answer)
 169 {
 170         GSList *cur = answer_find(event, answer);
 171         if (cur) {
 172                 Answer *b = (Answer *)cur->data;
 173                 event->answers = g_slist_remove(event->answers, b);
 174                 answer_free(b);
 175         }
 176         return event->answers;
 177 }
 178
 179 static GSList *answer_add(VCalEvent *event, Answer *answer)
 180 {
 181         event->answers = g_slist_append(event->answers, answer);
 182         return event->answers;
 183 }
 184
 185 GSList *vcal_manager_get_answers_emails(VCalEvent *event)
 186 {
 187         GSList *new = NULL;
 188         GSList *cur = event->answers;
 189         while (cur && cur->data) {
 190                 Answer *b = (Answer *)cur->data;
 191                 new = g_slist_prepend(new, b->attendee);
 192                 cur = cur->next;
 193         }
 194         new = g_slist_reverse(new);
 195         return new;
 196 }
 197
 198 enum icalparameter_partstat vcal_manager_get_reply_for_attendee(VCalEvent *event, const gchar *att)
 199 {
 200         Answer *a = answer_new(att, NULL, 0, 0);
 201         GSList *ans = answer_find(event, a);
 202         enum icalparameter_partstat res = 0;
 203         if (ans) {
 204                 Answer *b = (Answer *)ans->data;
 205                 res = b->answer;
 206         }
 207         answer_free(a);
 208         return res;
 209 }
 210
 211 gchar *vcal_manager_get_cutype_text_for_attendee(VCalEvent *event, const gchar *att)
 212 {
 213         enum icalparameter_cutype status = vcal_manager_get_cutype_for_attendee(event, att);
 214         gchar *res = NULL;
 215         if (status != 0)
 216                 res = g_strdup(vcal_manager_cutype_get_text(status));
 217
 218         return res;
 219 }
 220
 221 enum icalparameter_partstat vcal_manager_get_cutype_for_attendee(VCalEvent *event, const gchar *att)
 222 {
 223         Answer *a = answer_new(att, NULL, 0, 0);
 224         GSList *ans = answer_find(event, a);
 225         enum icalparameter_cutype res = 0;
 226         if (ans) {
 227                 Answer *b = (Answer *)ans->data;
 228                 res = b->cutype;
 229         }
 230         answer_free(a);
 231         return res;
 232 }
 233
 234 gchar *vcal_manager_get_reply_text_for_attendee(VCalEvent *event, const gchar *att)
 235 {
 236         enum icalparameter_partstat status = vcal_manager_get_reply_for_attendee(event, att);
 237         gchar *res = NULL;
 238         if (status != 0)
 239                 res = g_strdup(vcal_manager_answer_get_text(status));
 240
 241         return res;
 242 }
 243
 244 gchar *vcal_manager_get_attendee_name(VCalEvent *event, const gchar *att)
 245 {
 246         Answer *a = answer_new(att, NULL, 0, 0);
 247         GSList *ans = answer_find(event, a);
 248         gchar *res = NULL;
 249         if (ans) {
 250                 Answer *b = (Answer *)ans->data;
 251                 if (b->name)
 252                         res = g_strdup(b->name);
 253         }
 254         answer_free(a);
 255         return res;
 256 }
 257
 258 void vcal_manager_event_print(VCalEvent *event)
 259 {
 260         GSList *list = event->answers;
 261         printf( "event->uid\t\t%s\n"
 262                 "event->organizer\t\t%s\n"
 263                 "event->start\t\t%s\n"
 264                 "event->end\t\t%s\n"
 265                 "event->location\t\t%s\n"
 266                 "event->summary\t\t%s\n"
 267                 "event->description\t%s\n"
 268                 "event->url\t%s\n"
 269                 "event->dtstart\t\t%s\n"
 270                 "event->dtend\t\t%s\n"
 271                 "event->recur\t\t%s\n"
 272                 "event->tzid\t\t%s\n"
 273                 "event->method\t\t%d\n"
 274                 "event->sequence\t\t%d\n",
 275                 event->uid,
 276                 event->organizer,
 277                 event->start,
 278                 event->end,
 279                 event->location,
 280                 event->summary,
 281                 event->description,
 282                 event->url,
 283                 event->dtstart,
 284                 event->dtend,
 285                 event->recur,
 286                 event->tzid,
 287                 event->method,
 288                 event->sequence);
 289         while (list && list->data) {
 290                 Answer *a = (Answer *)list->data;
 291                 printf(" ans: %s %s, %s\n", a->name, a->attendee, vcal_manager_answer_get_text(a->answer));
 292                 list = list->next;
 293         }
 294
 295 }
 296
 297 static gchar *write_headers(PrefsAccount        *account,
 298                             VCalEvent           *event,
 299                             gboolean             short_headers,
 300                             gboolean             is_reply,
 301                             gboolean             is_pseudo_event);
 302
 303 gchar *vcal_manager_event_dump(VCalEvent *event, gboolean is_reply, gboolean is_pseudo_event,
 304                                 icalcomponent *use_calendar, gboolean modif)
 305 {
 306         gchar *organizer = g_strdup_printf("MAILTO:%s", event->organizer);
 307         PrefsAccount *account = vcal_manager_get_account_from_event(event);
 308         gchar *attendee  = NULL;
 309         gchar *body, *headers;
 310         gchar *tmpfile = NULL;
 311         icalcomponent *calendar, *ievent, *timezone, *tzc;
 312         icalproperty *attprop;
 313         icalproperty *orgprop;
 314         enum icalparameter_partstat status = ICAL_PARTSTAT_NEEDSACTION;
 315         gchar *sanitized_uid = g_strdup(event->uid);
 316
 317         subst_for_filename(sanitized_uid);
 318
 319         tmpfile = g_strdup_printf("%s%cevt-%d-%s", get_tmp_dir(),
 320                                       G_DIR_SEPARATOR, getuid(), sanitized_uid);
 321         g_free(sanitized_uid);
 322
 323         if (!account) {
 324                 g_free(organizer);
 325                 g_free(tmpfile);
 326                 debug_print("no account found\n");
 327                 return NULL;
 328         }
 329
 330         attendee = g_strdup_printf("MAILTO:%s", account->address);
 331
 332         if (vcal_manager_get_reply_for_attendee(event, account->address) != 0)
 333                 status = vcal_manager_get_reply_for_attendee(event, account->address);
 334
 335         tzset();
 336
 337         if (use_calendar != NULL) {
 338                 calendar = use_calendar;
 339                 g_free(tmpfile);
 340                 tmpfile = NULL;
 341         } else
 342                 calendar =
 343                         icalcomponent_vanew(
 344                             ICAL_VCALENDAR_COMPONENT,
 345                             icalproperty_new_version("2.0"),
 346                             icalproperty_new_prodid(
 347                                  "-//Claws Mail//NONSGML Claws Mail Calendar//EN"),
 348                             icalproperty_new_calscale("GREGORIAN"),
 349                             icalproperty_new_method(is_reply ? ICAL_METHOD_REPLY:event->method),
 350                             (void*)0
 351                             );
 352
 353         if (!calendar) {
 354                 g_warning ("can't generate calendar");
 355                 g_free(organizer);
 356                 g_free(tmpfile);
 357                 g_free(attendee);
 358                 return NULL;
 359         }
 360
 361         orgprop = icalproperty_new_organizer(organizer);
 362
 363         timezone = icalcomponent_new(ICAL_VTIMEZONE_COMPONENT);
 364
 365         icalcomponent_add_property(timezone,
 366                 icalproperty_new_tzid("UTC")); /* free */
 367
 368         tzc = icalcomponent_new(ICAL_XSTANDARD_COMPONENT);
 369         icalcomponent_add_property(tzc,
 370                 icalproperty_new_dtstart(
 371                         icaltime_from_string("19700101T000000")));
 372         icalcomponent_add_property(tzc,
 373                 icalproperty_new_tzoffsetfrom(0.0));
 374         icalcomponent_add_property(tzc,
 375                 icalproperty_new_tzoffsetto(0.0));
 376         icalcomponent_add_property(tzc,
 377                 icalproperty_new_tzname("Greenwich meridian time"));
 378
 379         icalcomponent_add_component(timezone, tzc);
 380
 381         ievent =
 382             icalcomponent_vanew(
 383                 ICAL_VEVENT_COMPONENT, (void*)0);
 384
 385         if (!ievent) {
 386                 g_warning ("can't generate event");
 387                 g_free(organizer);
 388                 g_free(tmpfile);
 389                 g_free(attendee);
 390                 return NULL;
 391         }
 392
 393         icalcomponent_add_property(ievent,
 394                 icalproperty_new_uid(event->uid));
 395         icalcomponent_add_property(ievent,
 396                 icalproperty_vanew_dtstamp(icaltime_from_timet(time(NULL), TRUE), 0));
 397         icalcomponent_add_property(ievent,
 398                 icalproperty_vanew_dtstart((icaltime_from_string(event->dtstart)), 0));
 399         icalcomponent_add_property(ievent,
 400                 icalproperty_vanew_dtend((icaltime_from_string(event->dtend)), 0));
 401         if (event->recur && *(event->recur)) {
 402                 icalcomponent_add_property(ievent,
 403                         icalproperty_vanew_rrule((icalrecurrencetype_from_string(event->recur)), 0));
 404         }
 405         icalcomponent_add_property(ievent,
 406                 icalproperty_new_description(event->description));
 407         icalcomponent_add_property(ievent,
 408                 icalproperty_new_summary(event->summary));
 409         icalcomponent_add_property(ievent,
 410                 icalproperty_new_sequence(modif && !is_reply ? event->sequence + 1 : event->sequence));
 411         icalcomponent_add_property(ievent,
 412                 icalproperty_new_class("PUBLIC"));
 413         icalcomponent_add_property(ievent,
 414                 icalproperty_new_transp("OPAQUE"));
 415         if (event->location && *event->location)
 416                 icalcomponent_add_property(ievent,
 417                         icalproperty_new_location(event->location));
 418         else
 419                 icalcomponent_add_property(ievent,
 420                         icalproperty_new_location(""));
 421         icalcomponent_add_property(ievent,
 422                 icalproperty_new_status(ICAL_STATUS_CONFIRMED));
 423         icalcomponent_add_property(ievent,
 424                 icalproperty_vanew_created(icaltime_from_timet(time(NULL), TRUE), 0));
 425         icalcomponent_add_property(ievent,
 426                 icalproperty_vanew_lastmodified(icaltime_from_timet(time(NULL), TRUE), 0));
 427         icalcomponent_add_property(ievent,
 428                 orgprop);
 429
 430         if (!icalcomponent_get_first_component(calendar, ICAL_VTIMEZONE_COMPONENT))
 431                 icalcomponent_add_component(calendar, timezone);
 432         else
 433                 icalcomponent_free(timezone);
 434
 435         icalcomponent_add_component(calendar, ievent);
 436
 437         if (event->url && *(event->url)) {
 438                 attprop = icalproperty_new_url(event->url);
 439                 icalcomponent_add_property(ievent, attprop);
 440         }
 441
 442         if (is_reply) {
 443                 /* dump only this attendee */
 444                 attprop =
 445                         icalproperty_vanew_attendee(
 446                             attendee,
 447                             icalparameter_new_role(
 448                                 ICAL_ROLE_REQPARTICIPANT),
 449                             icalparameter_new_rsvp(ICAL_RSVP_TRUE),
 450                             icalparameter_new_partstat(status),
 451                             0
 452                             );
 453                 icalcomponent_add_property(ievent, attprop);
 454         } else {
 455                 /* dump all attendees */
 456                 GSList *cur = event->answers;
 457                 while (cur && cur->data) {
 458                         Answer *a = (Answer *)cur->data;
 459
 460                         if (a->cutype == 0)
 461                                 a->cutype = ICAL_CUTYPE_INDIVIDUAL;
 462                         if (a->answer == 0)
 463                                 a->answer = ICAL_PARTSTAT_NEEDSACTION;
 464
 465                         attprop =
 466                                 icalproperty_vanew_attendee(
 467                                     a->attendee,
 468                                     icalparameter_new_role(
 469                                         ICAL_ROLE_REQPARTICIPANT),
 470                                     icalparameter_new_rsvp(ICAL_RSVP_TRUE),
 471                                     icalparameter_new_cutype(a->cutype),
 472                                     icalparameter_new_partstat(a->answer),
 473                                     0
 474                                     );
 475
 476                         icalcomponent_add_property(ievent, attprop);
 477                         cur = cur->next;
 478                 }
 479         }
 480
 481         if (use_calendar) {
 482                 g_free(organizer);
 483                 g_free(tmpfile);
 484                 g_free(attendee);
 485                 return NULL;
 486         }
 487
 488         headers = write_headers(account, event, is_pseudo_event, is_reply, is_pseudo_event);
 489
 490         if (!headers) {
 491                 g_warning("can't get headers");
 492                 g_free(organizer);
 493                 g_free(tmpfile);
 494                 g_free(attendee);
 495                 return NULL;
 496         }
 497
 498         body = g_strdup_printf("%s"
 499                                "\n"
 500                                "%s", headers, icalcomponent_as_ical_string(calendar));
 501
 502         if (str_write_to_file(body, tmpfile) < 0) {
 503                 g_free(tmpfile);
 504                 tmpfile = NULL;
 505         }
 506
 507         chmod(tmpfile, S_IRUSR|S_IWUSR);
 508
 509         g_free(body);
 510         g_free(headers);
 511         icalcomponent_free(calendar);
 512         g_free(attendee);
 513         g_free(organizer);
 514
 515         tzset();
 516
 517         return tmpfile;
 518 }
 519
 520 static void get_rfc822_date_from_time_t(gchar *buf, gint len, time_t t)
 521 {
 522 #ifndef G_OS_WIN32
 523         struct tm *lt;
 524         gchar day[4], mon[4];
 525         gint dd, hh, mm, ss, yyyy;
 526         gchar buft1[512];
 527         struct tm buft2;
 528
 529         lt = localtime_r(&t, &buft2);
 530         sscanf(asctime_r(lt, buft1), "%3s %3s %d %d:%d:%d %d\n",
 531                day, mon, &dd, &hh, &mm, &ss, &yyyy);
 532         g_snprintf(buf, len, "%s, %d %s %d %02d:%02d:%02d %s",
 533                    day, dd, mon, yyyy, hh, mm, ss, tzoffset(&t));
 534 #else
 535         GDateTime *dt = g_date_time_new_from_unix_local(t);
 536         gchar *buf2 = g_date_time_format(dt, "%a, %e %b %Y %H:%M:%S %Z");
 537         strncpy(buf, buf2, len);
 538         g_free(buf2);
 539 #endif
 540 }
 541
 542 static gchar *write_headers_date(const gchar *uid)
 543 {
 544         gchar subject[512];
 545         gchar *t_subject;
 546         gchar date[128];
 547         time_t t;
 548         struct tm lt;
 549         struct tm buft;
 550
 551         memset(subject, 0, sizeof(subject));
 552         memset(date, 0, sizeof(date));
 553
 554         if (!strcmp(uid, EVENT_PAST_ID)) {
 555                 t = 1;
 556                 t_subject = _("Past");
 557         } else if (!strcmp(uid, EVENT_TODAY_ID)) {
 558                 t = time(NULL);
 559                 t_subject = _("Today");
 560         }  else if (!strcmp(uid, EVENT_TOMORROW_ID)) {
 561                 t = time(NULL) + 86400;
 562                 t_subject = _("Tomorrow");
 563         }  else if (!strcmp(uid, EVENT_THISWEEK_ID)) {
 564                 t = time(NULL) + (86400*2);
 565                 t_subject = _("This week");
 566         }  else if (!strcmp(uid, EVENT_LATER_ID)) {
 567                 t = time(NULL) + (86400*7);
 568                 t_subject = _("Later");
 569         }  else {
 570                 g_warning("unknown spec date");
 571                 return NULL;
 572         }
 573
 574 #ifndef G_OS_WIN32
 575         lt = *localtime_r(&t, &buft);
 576 #else
 577         if (t < 0)
 578                 t = 1;
 579         lt = *localtime(&t);
 580 #endif
 581         lt.tm_hour = lt.tm_min = lt.tm_sec = 0;
 582         t = mktime(&lt);
 583         get_rfc822_date_from_time_t(date, sizeof(date), t);
 584         conv_encode_header(subject, 511, t_subject, strlen("Subject: "), FALSE);
 585
 586         return g_strdup_printf("From: -\n"
 587                                 "To: -\n"
 588                                 "Subject: %s\n"
 589                                 "Date: %s\n"
 590                                 "MIME-Version: 1.0\n"
 591                                 "Content-Type: text/plain; charset=\"UTF-8\";\n"
 592                                 "Content-Transfer-Encoding: quoted-printable\n"
 593                                 "Message-ID: <%s>\n",
 594                                 subject,
 595                                 date,
 596                                 uid);
 597 }
 598
 599 gchar *vcal_manager_dateevent_dump(const gchar *uid, FolderItem *item)
 600 {
 601         gchar *sanitized_uid = NULL;
 602         gchar *headers = NULL;
 603         gchar *lines, *body, *tmpfile;
 604         EventTime date;
 605         sanitized_uid = g_strdup(uid);
 606         subst_for_filename(sanitized_uid);
 607
 608         tmpfile = g_strdup_printf("%s%cevt-%d-%s", get_tmp_dir(),
 609                                    G_DIR_SEPARATOR, getuid(), sanitized_uid);
 610         g_free(sanitized_uid);
 611
 612         headers = write_headers_date(uid);
 613
 614         if (!headers) {
 615                 g_warning("can't get headers");
 616                 g_free(tmpfile);
 617                 return NULL;
 618         }
 619
 620         if (!strcmp(uid, EVENT_PAST_ID))
 621                 date = EVENT_PAST;
 622         else if (!strcmp(uid, EVENT_TODAY_ID))
 623                 date = EVENT_TODAY;
 624         else if (!strcmp(uid, EVENT_TOMORROW_ID))
 625                 date = EVENT_TOMORROW;
 626         else if (!strcmp(uid, EVENT_THISWEEK_ID))
 627                 date = EVENT_THISWEEK;
 628         else if (!strcmp(uid, EVENT_LATER_ID))
 629                 date = EVENT_LATER;
 630         else
 631                 date = EVENT_PAST;
 632
 633         lines = get_item_event_list_for_date(item, date);
 634         body = g_strdup_printf("%s"
 635                                "\n"
 636                                "%s", headers, lines);
 637         g_free(lines);
 638         if (str_write_to_file(body, tmpfile) < 0) {
 639                 g_free(tmpfile);
 640                 tmpfile = NULL;
 641         } else
 642                 chmod(tmpfile, S_IRUSR|S_IWUSR);
 643
 644         g_free(body);
 645         g_free(headers);
 646
 647         return tmpfile;
 648 }
 649
 650 static gchar *write_headers_ical(PrefsAccount   *account,
 651                             icalcomponent       *ievent,
 652                             gchar               *orga);
 653
 654 gchar *vcal_manager_icalevent_dump(icalcomponent *event, gchar *orga, icalcomponent *use_calendar)
 655 {
 656         PrefsAccount *account = account_get_cur_account();
 657         gchar *body, *headers, *qpbody;
 658         gchar **lines = NULL;
 659         gchar *tmpfile = NULL;
 660         icalcomponent *calendar;
 661         icalproperty *prop;
 662         icalcomponent *ievent = NULL;
 663         int i = 0;
 664
 665         ievent = icalcomponent_new_clone(event);
 666
 667         prop = icalcomponent_get_first_property(ievent, ICAL_UID_PROPERTY);
 668         if (prop) {
 669                 gchar *sanitized_uid = g_strdup(icalproperty_get_uid(prop));
 670
 671                 subst_for_filename(sanitized_uid);
 672
 673                 tmpfile = g_strdup_printf("%s%cevt-%d-%s", get_tmp_dir(),
 674                                               G_DIR_SEPARATOR, getuid(), sanitized_uid);
 675                 g_free(sanitized_uid);
 676                 icalproperty_free(prop);
 677         } else {
 678                 tmpfile = g_strdup_printf("%s%cevt-%d-%p", get_tmp_dir(),
 679                                       G_DIR_SEPARATOR, getuid(), ievent);
 680         }
 681
 682         if (!account) {
 683                 g_free(tmpfile);
 684                 icalcomponent_free(ievent);
 685                 return NULL;
 686         }
 687
 688         tzset();
 689
 690         if (use_calendar != NULL) {
 691                 calendar = use_calendar;
 692                 g_free(tmpfile);
 693                 tmpfile = NULL;
 694         } else
 695                 calendar =
 696                         icalcomponent_vanew(
 697                             ICAL_VCALENDAR_COMPONENT,
 698                             icalproperty_new_version("2.0"),
 699                             icalproperty_new_prodid(
 700                                  "-//Claws Mail//NONSGML Claws Mail Calendar//EN"),
 701                             icalproperty_new_calscale("GREGORIAN"),
 702                             icalproperty_new_method(ICAL_METHOD_PUBLISH),
 703                             (void*)0
 704                             );
 705
 706         if (!calendar) {
 707                 g_warning ("can't generate calendar");
 708                 g_free(tmpfile);
 709                 icalcomponent_free(ievent);
 710                 return NULL;
 711         }
 712
 713         icalcomponent_add_component(calendar, ievent);
 714
 715         if (use_calendar)
 716                 return NULL;
 717
 718         headers = write_headers_ical(account, ievent, orga);
 719
 720         if (!headers) {
 721                 g_warning("can't get headers");
 722                 g_free(tmpfile);
 723                 icalcomponent_free(calendar);
 724                 return NULL;
 725         }
 726
 727         lines = g_strsplit(icalcomponent_as_ical_string(calendar), "\n", 0);
 728         qpbody = g_strdup("");
 729
 730         /* encode to quoted-printable */
 731         while (lines[i]) {
 732                 gint e_len = strlen(qpbody), n_len = 0;
 733                 gchar *outline = conv_codeset_strdup(lines[i], CS_UTF_8, conv_get_outgoing_charset_str());
 734                 gchar *qpoutline = g_malloc(strlen(outline)*8 + 1);
 735
 736                 qp_encode_line(qpoutline, (guchar *)outline);
 737                 n_len = strlen(qpoutline);
 738
 739                 qpbody = g_realloc(qpbody, e_len + n_len + 1);
 740                 strcpy(qpbody+e_len, qpoutline);
 741                 *(qpbody+n_len+e_len) = '\0';
 742
 743                 g_free(outline);
 744                 g_free(qpoutline);
 745                 i++;
 746         }
 747
 748         body = g_strdup_printf("%s"
 749                                "\n"
 750                                "%s", headers, qpbody);
 751
 752         if (str_write_to_file(body, tmpfile) < 0) {
 753                 g_free(tmpfile);
 754                 tmpfile = NULL;
 755         } else
 756                 chmod(tmpfile, S_IRUSR|S_IWUSR);
 757
 758         g_strfreev(lines);
 759         g_free(body);
 760         g_free(qpbody);
 761         g_free(headers);
 762         icalcomponent_free(calendar);
 763
 764         return tmpfile;
 765 }
 766
 767 VCalEvent * vcal_manager_new_event      (const gchar    *uid,
 768                                          const gchar    *organizer,
 769                                          const gchar    *orgname,
 770                                          const gchar    *location,
 771                                          const gchar    *summary,
 772                                          const gchar    *description,
 773                                          const gchar    *dtstart,
 774                                          const gchar    *dtend,
 775                                          const gchar    *recur,
 776                                          const gchar    *tzid,
 777                                          const gchar    *url,
 778                                          enum icalproperty_method method,
 779                                          gint            sequence,
 780                                          enum icalcomponent_kind type)
 781 {
 782         VCalEvent *event = g_new0(VCalEvent, 1);
 783
 784         event->uid              = g_strdup(uid?uid:"");
 785         event->organizer        = g_strdup(organizer?organizer:"");
 786         event->orgname          = g_strdup(orgname?orgname:"");
 787
 788         if (dtend && *(dtend)) {
 789                 time_t tmp = icaltime_as_timet((icaltime_from_string(dtend)));
 790                 gchar buft[512];
 791                 tzset();
 792                 event->end      = g_strdup(ctime_r(&tmp, buft));
 793         }
 794
 795         if (dtstart && *(dtstart)) {
 796                 time_t tmp = icaltime_as_timet((icaltime_from_string(dtstart)));
 797                 gchar buft[512];
 798                 tzset();
 799                 event->start    = g_strdup(ctime_r(&tmp, buft));
 800         }
 801         event->dtstart          = g_strdup(dtstart?dtstart:"");
 802         event->dtend            = g_strdup(dtend?dtend:"");
 803         event->recur            = g_strdup(recur?recur:"");
 804         event->location         = g_strdup(location?location:"");
 805         event->summary          = g_strdup(summary?summary:"");
 806         event->description      = g_strdup(description?description:"");
 807         event->url              = g_strdup(url?url:"");
 808         event->tzid             = g_strdup(tzid?tzid:"");
 809         event->method           = method;
 810         event->sequence         = sequence;
 811         event->type             = type;
 812         event->rec_occurence            = FALSE;
 813         while (strchr(event->summary, '\n'))
 814                 *(strchr(event->summary, '\n')) = ' ';
 815
 816         return event;
 817 }
 818
 819 void vcal_manager_free_event (VCalEvent *event)
 820 {
 821         GSList *cur;
 822         if (!event)
 823                 return;
 824
 825         g_free(event->uid);
 826         g_free(event->organizer);
 827         g_free(event->orgname);
 828         g_free(event->start);
 829         g_free(event->end);
 830         g_free(event->location);
 831         g_free(event->summary);
 832         g_free(event->dtstart);
 833         g_free(event->dtend);
 834         g_free(event->recur);
 835         g_free(event->tzid);
 836         g_free(event->description);
 837         g_free(event->url);
 838         for (cur = event->answers; cur; cur = cur->next) {
 839                 answer_free((Answer *)cur->data);
 840         }
 841         g_slist_free(event->answers);
 842         g_free(event);
 843 }
 844
 845 gchar *vcal_manager_get_event_path(void)
 846 {
 847         static gchar *event_path = NULL;
 848         if (!event_path)
 849                 event_path = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
 850                                         "vcalendar", NULL);
 851
 852         return event_path;
 853 }
 854
 855 gchar *vcal_manager_get_event_file(const gchar *uid)
 856 {
 857         gchar *tmp = g_strdup(uid);
 858         gchar *res = NULL;
 859
 860         subst_for_filename(tmp);
 861         res = g_strconcat(vcal_manager_get_event_path(), G_DIR_SEPARATOR_S,
 862                            tmp, NULL);
 863         g_free(tmp);
 864         return res;
 865 }
 866
 867 PrefsAccount *vcal_manager_get_account_from_event(VCalEvent *event)
 868 {
 869         GSList *list = vcal_manager_get_answers_emails(event);
 870         GSList *cur = list;
 871
 872         /* find an attendee corresponding to one of our accounts */
 873         while (cur && cur->data) {
 874                 gchar *email = (gchar *)cur->data;
 875                 if (account_find_from_address(email, FALSE)) {
 876                         g_slist_free(list);
 877                         return account_find_from_address(email, FALSE);
 878                 }
 879                 cur = cur->next;
 880         }
 881         g_slist_free(list);
 882         return NULL;
 883 }
 884
 885 void vcal_manager_save_event (VCalEvent *event, gboolean export_after)
 886 {
 887         XMLTag *tag = NULL;
 888         XMLNode *xmlnode = NULL;
 889         GNode *rootnode = NULL;
 890         PrefFile *pfile;
 891         gchar *path = NULL;
 892         GSList *answers = event->answers;
 893         gchar *tmp = NULL;
 894         gint tmp_method = event->method;
 895
 896         tag = xml_tag_new("event");
 897         xml_tag_add_attr(tag, xml_attr_new("organizer", event->organizer));
 898         xml_tag_add_attr(tag, xml_attr_new("orgname", event->orgname));
 899         xml_tag_add_attr(tag, xml_attr_new("location", event->location));
 900         xml_tag_add_attr(tag, xml_attr_new("summary", event->summary));
 901         xml_tag_add_attr(tag, xml_attr_new("description", event->description));
 902         xml_tag_add_attr(tag, xml_attr_new("url", event->url));
 903         xml_tag_add_attr(tag, xml_attr_new("dtstart", event->dtstart));
 904         xml_tag_add_attr(tag, xml_attr_new("dtend", event->dtend));
 905         xml_tag_add_attr(tag, xml_attr_new("recur", event->recur));
 906         xml_tag_add_attr(tag, xml_attr_new("tzid", event->tzid));
 907
 908         /* updating answers saves events, don't save them with reply type */
 909         if (tmp_method == ICAL_METHOD_REPLY)
 910                 tmp_method = ICAL_METHOD_REQUEST;
 911
 912         tmp = g_strdup_printf("%d", tmp_method);
 913         xml_tag_add_attr(tag, xml_attr_new("method", tmp));
 914         g_free(tmp);
 915
 916         tmp = g_strdup_printf("%d", event->sequence);
 917         xml_tag_add_attr(tag, xml_attr_new("sequence", tmp));
 918         g_free(tmp);
 919
 920         tmp = g_strdup_printf("%d", event->type);
 921         xml_tag_add_attr(tag, xml_attr_new("type", tmp));
 922         g_free(tmp);
 923
 924         tmp = g_strdup_printf("%lld", (long long)event->postponed);
 925         xml_tag_add_attr(tag, xml_attr_new("postponed", tmp));
 926         g_free(tmp);
 927
 928         tmp = g_strdup_printf("%d", event->rec_occurence);
 929         xml_tag_add_attr(tag, xml_attr_new("rec_occurence", tmp));
 930         g_free(tmp);
 931
 932         xmlnode = xml_node_new(tag, NULL);
 933         rootnode = g_node_new(xmlnode);
 934
 935         while (answers && answers->data) {
 936                 XMLNode *ansxmlnode = NULL;
 937                 GNode *ansnode = NULL;
 938                 XMLTag *anstag = xml_tag_new("answer");
 939                 Answer *a = (Answer *)answers->data;
 940                 xml_tag_add_attr(anstag, xml_attr_new("attendee", a->attendee));
 941                 xml_tag_add_attr(anstag, xml_attr_new("name", a->name?a->name:""));
 942                 tmp = g_strdup_printf("%d", a->answer);
 943                 xml_tag_add_attr(anstag, xml_attr_new("answer", tmp));
 944                 g_free(tmp);
 945                 tmp = g_strdup_printf("%d", a->cutype);
 946                 xml_tag_add_attr(anstag, xml_attr_new("cutype", tmp));
 947                 g_free(tmp);
 948                 ansxmlnode = xml_node_new(anstag, NULL);
 949                 ansnode = g_node_new(ansxmlnode);
 950                 g_node_append(rootnode, ansnode);
 951                 answers = answers->next;
 952         }
 953
 954         path = vcal_manager_get_event_file(event->uid);
 955
 956         if ((pfile = prefs_write_open(path)) == NULL) {
 957                 gchar *dir_path = vcal_manager_get_event_path();
 958                 if (!is_dir_exist(dir_path) && make_dir(vcal_manager_get_event_path()) != 0) {
 959                         g_free(dir_path);
 960                         g_free(path);
 961                         return;
 962                 }
 963                 g_free(dir_path);
 964                 if ((pfile = prefs_write_open(path)) == NULL) {
 965                         g_free(path);
 966                         return;
 967                 }
 968         }
 969
 970         g_free(path);
 971         xml_file_put_xml_decl(pfile->fp);
 972         xml_write_tree(rootnode, pfile->fp);
 973         xml_free_tree(rootnode);
 974
 975         if (prefs_file_close(pfile) < 0) {
 976                 g_warning("failed to write event.");
 977                 return;
 978         }
 979
 980         if (export_after)
 981                 vcal_folder_export(NULL);
 982 }
 983
 984 static VCalEvent *event_get_from_xml (const gchar *uid, GNode *node)
 985 {
 986         XMLNode *xmlnode;
 987         GList *list;
 988         gchar *org = NULL, *location = NULL, *summary = NULL, *orgname = NULL;
 989         gchar *dtstart = NULL, *dtend = NULL, *tzid = NULL;
 990         gchar *description = NULL, *url = NULL, *recur = NULL;
 991         VCalEvent *event = NULL;
 992         enum icalproperty_method method = ICAL_METHOD_REQUEST;
 993         enum icalcomponent_kind type = ICAL_VEVENT_COMPONENT;
 994         gint sequence = 0, rec_occurence = 0;
 995         time_t postponed = (time_t)0;
 996
 997         g_return_val_if_fail(node->data != NULL, NULL);
 998
 999         xmlnode = node->data;
1000         if (strcmp2(xmlnode->tag->tag, "event") != 0) {
1001                 g_warning("tag name != \"event\"");
1002                 return NULL;
1003         }
1004
1005         list = xmlnode->tag->attr;
1006         for (; list != NULL; list = list->next) {
1007                 XMLAttr *attr = list->data;
1008
1009                 if (!attr || !attr->name || !attr->value) continue;
1010                 if (!strcmp(attr->name, "organizer"))
1011                         org = g_strdup(attr->value);
1012                 if (!strcmp(attr->name, "orgname"))
1013                         orgname = g_strdup(attr->value);
1014                 if (!strcmp(attr->name, "location"))
1015                         location = g_strdup(attr->value);
1016                 if (!strcmp(attr->name, "summary"))
1017                         summary = g_strdup(attr->value);
1018                 if (!strcmp(attr->name, "description"))
1019                         description = g_strdup(attr->value);
1020                 if (!strcmp(attr->name, "url"))
1021                         url = g_strdup(attr->value);
1022                 if (!strcmp(attr->name, "dtstart"))
1023                         dtstart = g_strdup(attr->value);
1024                 if (!strcmp(attr->name, "dtend"))
1025                         dtend = g_strdup(attr->value);
1026                 if (!strcmp(attr->name, "recur"))
1027                         recur = g_strdup(attr->value);
1028                 if (!strcmp(attr->name, "tzid"))
1029                         tzid = g_strdup(attr->value);
1030                 if (!strcmp(attr->name, "type"))
1031                         type = atoi(attr->value);
1032                 if (!strcmp(attr->name, "method"))
1033                         method = atoi(attr->value);
1034                 if (!strcmp(attr->name, "sequence"))
1035                         sequence = atoi(attr->value);
1036                 if (!strcmp(attr->name, "postponed"))
1037                         postponed = atoi(attr->value);
1038                 if (!strcmp(attr->name, "rec_occurence"))
1039                         rec_occurence = atoi(attr->value);
1040         }
1041
1042         event = vcal_manager_new_event(uid, org, orgname, location, summary, description,
1043                                         dtstart, dtend, recur, tzid, url, method,
1044                                         sequence, type);
1045
1046         event->postponed = postponed;
1047         event->rec_occurence = rec_occurence;
1048
1049         g_free(org);
1050         g_free(orgname);
1051         g_free(location);
1052         g_free(summary);
1053         g_free(description);
1054         g_free(url);
1055         g_free(dtstart);
1056         g_free(dtend);
1057         g_free(recur);
1058         g_free(tzid);
1059
1060         node = node->children;
1061         while (node != NULL) {
1062                 gchar *attendee = NULL;
1063                 gchar *name = NULL;
1064                 enum icalparameter_partstat answer = ICAL_PARTSTAT_NEEDSACTION;
1065                 enum icalparameter_cutype cutype   = ICAL_CUTYPE_INDIVIDUAL;
1066
1067                 xmlnode = node->data;
1068                 if (strcmp2(xmlnode->tag->tag, "answer") != 0) {
1069                         g_warning("tag name != \"answer\"");
1070                         return event;
1071                 }
1072                 list = xmlnode->tag->attr;
1073                 for (; list != NULL; list = list->next) {
1074                         XMLAttr *attr = list->data;
1075
1076                         if (!attr || !attr->name || !attr->value) continue;
1077                         if (!strcmp(attr->name, "attendee"))
1078                                 attendee = g_strdup(attr->value);
1079                         if (!strcmp(attr->name, "name"))
1080                                 name = g_strdup(attr->value);
1081                         if (!strcmp(attr->name, "answer"))
1082                                 answer = atoi(attr->value);
1083                         if (!strcmp(attr->name, "cutype"))
1084                                 cutype = atoi(attr->value);
1085                 }
1086
1087                 event->answers = g_slist_prepend(event->answers, answer_new(attendee, name, answer, cutype));
1088                 g_free(attendee);
1089                 g_free(name);
1090                 node = node->next;
1091         }
1092         event->answers = g_slist_reverse(event->answers);
1093
1094         return event;
1095 }
1096
1097 VCalEvent *vcal_manager_load_event (const gchar *uid)
1098 {
1099         GNode *node;
1100         gchar *path = NULL;
1101         VCalEvent *event = NULL;
1102
1103         path = vcal_manager_get_event_file(uid);
1104
1105         if (!is_file_exist(path)) {
1106                 g_free(path);
1107                 return NULL;
1108         }
1109
1110         node = xml_parse_file(path);
1111
1112         g_free(path);
1113
1114         if (!node) {
1115                 g_warning("no node");
1116                 return NULL;
1117         }
1118
1119         event = event_get_from_xml(uid, node);
1120         /* vcal_manager_event_print(event); */
1121         xml_free_tree(node);
1122
1123         if (!event)
1124                 return NULL;
1125
1126         while (strchr(event->summary, '\n'))
1127                 *(strchr(event->summary, '\n')) = ' ';
1128
1129         return event;
1130
1131 }
1132
1133 void vcal_manager_update_answer (VCalEvent      *event,
1134                                  const gchar    *attendee,
1135                                  const gchar    *name,
1136                                  enum icalparameter_partstat ans,
1137                                  enum icalparameter_cutype cutype)
1138 {
1139         Answer *answer = NULL;
1140         GSList *existing = NULL;
1141         Answer *existing_a = NULL;
1142
1143         if (!ans)
1144                 return;
1145
1146         answer = answer_new(attendee, name, ans, cutype);
1147         existing = answer_find(event, answer);
1148
1149         if (existing) {
1150                 existing_a = (Answer *)existing->data;
1151
1152                 if (!answer->name && existing_a->name)
1153                         answer->name = g_strdup(existing_a->name);
1154                 if (!answer->cutype && existing_a->cutype)
1155                         answer->cutype = existing_a->cutype;
1156
1157                 answer_remove(event, answer);
1158         }
1159
1160         answer_add(event, answer);
1161
1162         vcal_manager_save_event(event, FALSE);
1163 }
1164
1165 static gchar *write_headers(PrefsAccount        *account,
1166                             VCalEvent           *event,
1167                             gboolean             short_headers,
1168                             gboolean             is_reply,
1169                             gboolean             is_pseudo_display)
1170 {
1171         gchar *subject = NULL;
1172         gchar date[128];
1173         gchar *save_folder = NULL;
1174         gchar *result = NULL;
1175         gchar *queue_headers = NULL;
1176         gchar *method_str = NULL;
1177         gchar *attendees = NULL;
1178         enum icalparameter_partstat status;
1179         gchar *prefix = NULL;
1180         gchar enc_subject[512], enc_from[512], *from = NULL;
1181         gchar msgid[128];
1182         gchar *calmsgid = NULL;
1183
1184         cm_return_val_if_fail(account != NULL, NULL);
1185
1186         memset(date, 0, sizeof(date));
1187
1188         if (is_pseudo_display) {
1189                 struct icaltimetype itt = (icaltime_from_string(event->dtstart));
1190                 time_t t = icaltime_as_timet(itt);
1191                 get_rfc822_date_from_time_t(date, sizeof(date), t);
1192         } else {
1193                 get_rfc822_date(date, sizeof(date));
1194         }
1195
1196         if (account_get_special_folder(account, F_OUTBOX)) {
1197                 save_folder = folder_item_get_identifier(account_get_special_folder
1198                                   (account, F_OUTBOX));
1199         }
1200
1201         if (!is_reply) {
1202                 GSList *cur = event->answers;
1203                 while (cur && cur->data) {
1204                         gchar *tmp = NULL;
1205                         Answer *a = (Answer *)cur->data;
1206
1207                         if (strcasecmp(a->attendee, event->organizer)) {
1208                                 if (attendees) {
1209                                         tmp = g_strdup_printf("%s>,\n <%s", attendees, a->attendee);
1210                                         g_free(attendees);
1211                                         attendees = tmp;
1212                                 } else {
1213                                         attendees = g_strdup_printf("%s", a->attendee);
1214                                 }
1215                         }
1216                         cur = cur->next;
1217                 }
1218         }
1219
1220         if (!short_headers) {
1221                 queue_headers = g_strdup_printf("S:%s\n"
1222                                 "SSV:%s\n"
1223                                 "R:<%s>\n"
1224                                 "MAID:%d\n"
1225                                 "%s%s%s"
1226                                 "X-Claws-End-Special-Headers: 1\n",
1227                                 account->address,
1228                                 account->smtp_server,
1229                                 is_reply ? event->organizer:attendees,
1230                                 account->account_id,
1231                                 save_folder?"SCF:":"",
1232                                 save_folder?save_folder:"",
1233                                 save_folder?"\n":"");
1234         } else {
1235                 queue_headers = g_strdup("");
1236         }
1237
1238         prefix = "";
1239         if (is_reply) {
1240                 method_str = "REPLY";
1241                 status = vcal_manager_get_reply_for_attendee(event, account->address);
1242                 if (status == ICAL_PARTSTAT_ACCEPTED)
1243                         prefix = _("Accepted: ");
1244                 else if (status == ICAL_PARTSTAT_DECLINED)
1245                         prefix = _("Declined: ");
1246                 else if (status == ICAL_PARTSTAT_TENTATIVE)
1247                         prefix = _("Tentatively Accepted: ");
1248                 else
1249                         prefix = "Re: ";
1250         } else if (event->method == ICAL_METHOD_PUBLISH) {
1251                 method_str = "PUBLISH";
1252         } else if (event->method == ICAL_METHOD_CANCEL) {
1253                 method_str = "CANCEL";
1254         } else {
1255                 method_str = "REQUEST";
1256         }
1257
1258         subject = g_strdup_printf("%s%s", prefix, event->summary);
1259
1260         conv_encode_header_full(enc_subject, sizeof(enc_subject), subject, strlen("Subject: "),
1261                         FALSE, conv_get_outgoing_charset_str());
1262         from = is_reply?account->name:(event->orgname?event->orgname:"");
1263         conv_encode_header_full(enc_from, sizeof(enc_from), from, strlen("From: "),
1264                         TRUE, conv_get_outgoing_charset_str());
1265
1266         if (is_pseudo_display && event->uid) {
1267                 calmsgid = g_strdup_printf("Message-ID: <%s>\n",event->uid);
1268         } else {
1269                 calmsgid = g_strdup("");
1270         }
1271
1272         if (account && account->set_domain && account->domain) {
1273                 g_snprintf(msgid, sizeof(msgid), "%s", account->domain);
1274         } else if (!strncmp(get_domain_name(), "localhost", strlen("localhost"))) {
1275                 g_snprintf(msgid, sizeof(msgid), "%s",
1276                         strchr(account->address, '@') ?
1277                                 strchr(account->address, '@')+1 :
1278                                 account->address);
1279         } else {
1280                 g_snprintf(msgid, sizeof(msgid), "%s", "");
1281         }
1282
1283         generate_msgid(msgid, sizeof(msgid), account->address);
1284
1285         result = g_strdup_printf("%s"
1286                                 "From: %s <%s>\n"
1287                                 "To: <%s>\n"
1288                                 "Subject: %s\n"
1289                                 "Date: %s\n"
1290                                 "MIME-Version: 1.0\n"
1291                                 "Content-Type: text/calendar; method=%s; charset=\"%s\"\n"
1292                                 "Content-Transfer-Encoding: 8bit\n"
1293                                 "%s"
1294                                 "%s: <%s>\n",
1295                                 queue_headers,
1296                                 enc_from,
1297                                 is_reply ? account->address:event->organizer,
1298                                 is_reply ? event->organizer:(attendees?attendees:event->organizer),
1299                                 enc_subject,
1300                                 date,
1301                                 method_str,
1302                                 CS_UTF_8,
1303                                 calmsgid,
1304                                 is_pseudo_display?
1305                                         "In-Reply-To":"Message-ID",
1306                                 is_pseudo_display?
1307                                         event_to_today_str(event, 0):msgid);
1308         g_free(calmsgid);
1309         g_free(subject);
1310         g_free(save_folder);
1311         g_free(queue_headers);
1312         g_free(attendees);
1313         return result;
1314
1315
1316 }
1317
1318 static gchar *write_headers_ical(PrefsAccount   *account,
1319                             icalcomponent       *ievent,
1320                             gchar               *orga)
1321 {
1322         gchar subject[512];
1323         gchar date[128];
1324         gchar *result = NULL;
1325         gchar *method_str = NULL;
1326         gchar *summary = NULL;
1327         gchar *organizer = NULL;
1328         gchar *orgname = NULL;
1329         icalproperty *prop = NULL;
1330         gchar *calmsgid = NULL;
1331
1332         time_t t = (time_t)0;
1333
1334         memset(subject, 0, sizeof(subject));
1335         memset(date, 0, sizeof(date));
1336
1337         prop = icalcomponent_get_first_property(ievent, ICAL_SUMMARY_PROPERTY);
1338         if (prop) {
1339                 summary = g_strdup(icalproperty_get_summary(prop));
1340                 icalproperty_free(prop);
1341         } else {
1342                 summary = g_strdup("");
1343         }
1344
1345         while (strchr(summary, '\n'))
1346                 *(strchr(summary, '\n')) = ' ';
1347
1348         prop = icalcomponent_get_first_property(ievent, ICAL_ORGANIZER_PROPERTY);
1349         if (prop) {
1350                 organizer = g_strdup(icalproperty_get_organizer(prop));
1351                 if (icalproperty_get_parameter_as_string(prop, "CN") != NULL)
1352                         orgname = g_strdup(icalproperty_get_parameter_as_string(prop, "CN"));
1353
1354                 icalproperty_free(prop);
1355         } else {
1356                 organizer = orga? g_strdup(orga):g_strdup("");
1357         }
1358
1359         prop = icalcomponent_get_first_property(ievent, ICAL_DTSTART_PROPERTY);
1360         if (prop) {
1361                 t = icaltime_as_timet(icalproperty_get_dtstart(prop));
1362                 get_rfc822_date_from_time_t(date, sizeof(date), t);
1363         } else {
1364                 get_rfc822_date(date, sizeof(date));
1365         }
1366
1367         conv_encode_header(subject, 511, summary, strlen("Subject: "), FALSE);
1368
1369         method_str = "PUBLISH";
1370
1371         prop = icalcomponent_get_first_property(ievent, ICAL_UID_PROPERTY);
1372         if (prop) {
1373                 calmsgid = g_strdup_printf("Message-ID: <%s>\n",icalproperty_get_uid(prop));
1374                 icalproperty_free(prop);
1375         } else {
1376                 calmsgid = g_strdup("");
1377         }
1378
1379
1380         result = g_strdup_printf("From: %s <%s>\n"
1381                                 "To: <%s>\n"
1382                                 "Subject: %s%s\n"
1383                                 "Date: %s\n"
1384                                 "MIME-Version: 1.0\n"
1385                                 "Content-Type: text/calendar; method=%s; charset=\"%s\"; vcalsave=\"no\"\n"
1386                                 "Content-Transfer-Encoding: quoted-printable\n"
1387                                 "%s"
1388                                 "In-Reply-To: <%s>\n",
1389                                 orgname?orgname:"",
1390                                 !strncmp(organizer, "MAILTO:", 7) ? organizer+7 : organizer,
1391                                 account->address,
1392                                 "",
1393                                 subject,
1394                                 date,
1395                                 method_str,
1396                                 conv_get_outgoing_charset_str(),
1397                                 calmsgid,
1398                                 event_to_today_str(NULL, t));
1399
1400         g_free(calmsgid);
1401         g_free(orgname);
1402         g_free(organizer);
1403         g_free(summary);
1404
1405         return result;
1406
1407
1408 }
1409
1410 static gboolean vcal_manager_send (PrefsAccount         *account,
1411                                      VCalEvent          *event,
1412                                      gboolean            is_reply)
1413 {
1414         gchar *tmpfile = NULL;
1415         gint msgnum;
1416         FolderItem *folderitem;
1417         gchar *msgpath = NULL;
1418         Folder *folder = NULL;
1419
1420         tmpfile = vcal_manager_event_dump(event, is_reply, FALSE, NULL, TRUE);
1421
1422         if (!tmpfile)
1423                 return FALSE;
1424
1425         folderitem = account_get_special_folder(account, F_QUEUE);
1426         if (!folderitem) {
1427                 g_warning("can't find queue folder for %s", account->address);
1428                 g_unlink(tmpfile);
1429                 g_free(tmpfile);
1430                 return FALSE;
1431         }
1432         folder_item_scan(folderitem);
1433
1434         if ((msgnum = folder_item_add_msg(folderitem, tmpfile, NULL, TRUE)) < 0) {
1435                 g_warning("can't queue the message");
1436                 g_unlink(tmpfile);
1437                 g_free(tmpfile);
1438                 return FALSE;
1439         }
1440
1441         msgpath = folder_item_fetch_msg(folderitem, msgnum);
1442
1443         if (!prefs_common_get_prefs()->work_offline) {
1444                 gchar *err = NULL;
1445                 gboolean queued_removed = FALSE;
1446                 gint val = procmsg_send_message_queue_with_lock(msgpath, &err, folderitem, msgnum, &queued_removed);
1447                 if (val == 0) {
1448                         if (!queued_removed)
1449                                 folder_item_remove_msg(folderitem, msgnum);
1450                         folder_item_scan(folderitem);
1451                 } else if (err) {
1452                         alertpanel_error_log("%s", err);
1453                         g_free(err);
1454                 }
1455         }
1456         g_unlink(tmpfile);
1457         g_free(tmpfile);
1458         g_free(msgpath);
1459
1460         folder = folder_find_from_name ("vCalendar", vcal_folder_get_class());
1461         if (folder)
1462                 folder_item_scan(folder->inbox);
1463
1464         vcalviewer_reload(folder->inbox);
1465         return TRUE;
1466 }
1467
1468 gboolean vcal_manager_reply (PrefsAccount       *account,
1469                              VCalEvent          *event)
1470 {
1471         return vcal_manager_send(account, event, TRUE);
1472 }
1473
1474 gboolean vcal_manager_request (PrefsAccount     *account,
1475                                VCalEvent        *event)
1476 {
1477         return vcal_manager_send(account, event, FALSE);
1478 }
1479
1480 EventTime event_to_today(VCalEvent *event, time_t t)
1481 {
1482         struct tm evtstart, today;
1483         time_t evtstart_t, today_t;
1484         struct icaltimetype itt;
1485         struct tm buft;
1486
1487         tzset();
1488
1489         today_t = time(NULL);
1490         if (event) {
1491                 itt = icaltime_from_string(event->dtstart);
1492                 evtstart_t = icaltime_as_timet(itt);
1493         } else {
1494                 evtstart_t = t;
1495         }
1496
1497 #ifndef G_OS_WIN32
1498         today = *localtime_r(&today_t, &buft);
1499         localtime_r(&evtstart_t, &evtstart);
1500 #else
1501         if (today_t < 0)
1502                 today_t = 1;
1503         if (evtstart_t < 0)
1504                 evtstart_t = 1;
1505         today = *localtime(&today_t);
1506         evtstart = *localtime(&evtstart_t);
1507 #endif
1508
1509         if (today.tm_year == evtstart.tm_year) {
1510                 int days = evtstart.tm_yday - today.tm_yday;
1511                 if (days < 0) {
1512                         return EVENT_PAST;
1513                 } else if (days == 0) {
1514                         return EVENT_TODAY;
1515                 } else if (days == 1) {
1516                         return EVENT_TOMORROW;
1517                 } else if (days > 1 && days < 7) {
1518                         return EVENT_THISWEEK;
1519                 } else {
1520                         return EVENT_LATER;
1521                 }
1522         } else if (today.tm_year > evtstart.tm_year) {
1523                 return EVENT_PAST;
1524         } else if (today.tm_year == evtstart.tm_year - 1) {
1525                 int days = ((365 - today.tm_yday) + evtstart.tm_yday);
1526                 if (days == 0) {
1527                         return EVENT_TODAY;
1528                 } else if (days == 1) {
1529                         return EVENT_TOMORROW;
1530                 } else if (days > 1 && days < 7) {
1531                         return EVENT_THISWEEK;
1532                 } else {
1533                         return EVENT_LATER;
1534                 }
1535         } else
1536                 return EVENT_LATER;
1537 }
1538
1539 const gchar *event_to_today_str(VCalEvent *event, time_t t)
1540 {
1541         EventTime days = event_to_today(event, t);
1542         switch(days) {
1543         case EVENT_PAST:
1544                 return EVENT_PAST_ID;
1545         case EVENT_TODAY:
1546                 return EVENT_TODAY_ID;
1547         case EVENT_TOMORROW:
1548                 return EVENT_TOMORROW_ID;
1549         case EVENT_THISWEEK:
1550                 return EVENT_THISWEEK_ID;
1551         case EVENT_LATER:
1552                 return EVENT_LATER_ID;
1553         }
1554         return NULL;
1555 }