Break out different import/export formats

Extract iCal and pcal import/export routines into separate files. This
reduces complexity of the super huge "io.c" source file and makes it
easier to follow changes that affect the iCal and pcal routines only
(commits affecting both formats are very uncommon).

Before:

    $ wc -l src/io.c
    2938 src/io.c

After:

    $ wc -l src/{io,ical,pcal}.c
     1445 src/io.c
     1263 src/ical.c
      317 src/pcal.c
     3025 total

Signed-off-by: Lukas Fleischer <calcurse@cryptocrack.de>

1 files changed, 1263 insertions, 0 deletions

diff --git a/src/ical.c b/src/ical.c
new file mode 100644
index 0000000..a40f94a
--- /dev/null
+++ b/src/ical.c
@@ -0,0 +1,1263 @@
+/*
+ * Calcurse - text-based organizer
+ *
+ * Copyright (c) 2004-2011 calcurse Development Team <misc@calcurse.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *      - Redistributions of source code must retain the above
+ *        copyright notice, this list of conditions and the
+ *        following disclaimer.
+ *
+ *      - Redistributions in binary form must reproduce the above
+ *        copyright notice, this list of conditions and the
+ *        following disclaimer in the documentation and/or other
+ *        materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Send your feedback or comments to : misc@calcurse.org
+ * Calcurse home page : http://calcurse.org
+ *
+ */
+
+#include <sys/types.h>
+
+#include "calcurse.h"
+#include "sha1.h"
+
+#define ICALDATEFMT      "%Y%m%d"
+#define ICALDATETIMEFMT  "%Y%m%dT%H%M%S"
+
+typedef enum {
+  ICAL_VEVENT,
+  ICAL_VTODO,
+  ICAL_TYPES
+} ical_types_e;
+
+typedef enum {
+  UNDEFINED,
+  APPOINTMENT,
+  EVENT
+} ical_vevent_e;
+
+typedef struct {
+  enum recur_type type;
+  int             freq;
+  long            until;
+  unsigned        count;
+} ical_rpt_t;
+
+static void ical_export_header (FILE *);
+static void ical_export_recur_events (FILE *);
+static void ical_export_events (FILE *);
+static void ical_export_recur_apoints (FILE *);
+static void ical_export_apoints (FILE *);
+static void ical_export_todo (FILE *);
+static void ical_export_footer (FILE *);
+
+static char *ical_recur_type[RECUR_TYPES] =
+  { "", "DAILY", "WEEKLY", "MONTHLY", "YEARLY" };
+
+/* iCal alarm notification. */
+static void
+ical_export_valarm (FILE *stream)
+{
+  fputs ("BEGIN:VALARM\n", stream);
+  pthread_mutex_lock (&nbar.mutex);
+  fprintf (stream, "TRIGGER:-P%dS\n", nbar.cntdwn);
+  pthread_mutex_unlock (&nbar.mutex);
+  fputs ("ACTION:DISPLAY\n", stream);
+  fputs ("END:VALARM\n", stream);
+}
+
+/* Export header. */
+static void
+ical_export_header (FILE *stream)
+{
+  fputs ("BEGIN:VCALENDAR\n", stream);
+  fprintf (stream, "PRODID:-//calcurse//NONSGML v%s//EN\n", VERSION);
+  fputs ("VERSION:2.0\n", stream);
+}
+
+/* Export footer. */
+static void
+ical_export_footer (FILE *stream)
+{
+  fputs ("END:VCALENDAR\n", stream);
+}
+
+/* Export recurrent events. */
+static void
+ical_export_recur_events (FILE *stream)
+{
+  llist_item_t *i, *j;
+  char ical_date[BUFSIZ];
+
+  LLIST_FOREACH (&recur_elist, i)
+    {
+      struct recur_event *rev = LLIST_GET_DATA (i);
+      date_sec2date_fmt (rev->day, ICALDATEFMT, ical_date);
+      fputs ("BEGIN:VEVENT\n", stream);
+      fprintf (stream, "DTSTART:%s\n", ical_date);
+      fprintf (stream, "RRULE:FREQ=%s;INTERVAL=%d",
+               ical_recur_type[rev->rpt->type], rev->rpt->freq);
+
+      if (rev->rpt->until != 0)
+        {
+          date_sec2date_fmt (rev->rpt->until, ICALDATEFMT, ical_date);
+          fprintf (stream, ";UNTIL=%s\n", ical_date);
+        }
+      else
+        fputc ('\n', stream);
+
+      if (LLIST_FIRST (&rev->exc))
+        {
+          fputs ("EXDATE:", stream);
+          LLIST_FOREACH (&rev->exc, j)
+            {
+              struct excp *exc = LLIST_GET_DATA (j);
+              date_sec2date_fmt (exc->st, ICALDATEFMT, ical_date);
+              fprintf (stream, "%s", ical_date);
+              if (LLIST_NEXT (j))
+                fputc (',', stream);
+              else
+                fputc ('\n', stream);
+            }
+        }
+
+      fprintf (stream, "SUMMARY:%s\n", rev->mesg);
+      fputs ("END:VEVENT\n", stream);
+    }
+}
+
+/* Export events. */
+static void
+ical_export_events (FILE *stream)
+{
+  llist_item_t *i;
+  char ical_date[BUFSIZ];
+
+  LLIST_FOREACH (&eventlist, i)
+    {
+      struct event *ev = LLIST_TS_GET_DATA (i);
+      date_sec2date_fmt (ev->day, ICALDATEFMT, ical_date);
+      fputs ("BEGIN:VEVENT\n", stream);
+      fprintf (stream, "DTSTART:%s\n", ical_date);
+      fprintf (stream, "SUMMARY:%s\n", ev->mesg);
+      fputs ("END:VEVENT\n", stream);
+    }
+}
+
+/* Export recurrent appointments. */
+static void
+ical_export_recur_apoints (FILE *stream)
+{
+  llist_item_t *i, *j;
+  char ical_datetime[BUFSIZ];
+  char ical_date[BUFSIZ];
+
+  LLIST_TS_LOCK (&recur_alist_p);
+  LLIST_TS_FOREACH (&recur_alist_p, i)
+    {
+      struct recur_apoint *rapt = LLIST_TS_GET_DATA (i);
+
+      date_sec2date_fmt (rapt->start, ICALDATETIMEFMT, ical_datetime);
+      fputs ("BEGIN:VEVENT\n", stream);
+      fprintf (stream, "DTSTART:%s\n", ical_datetime);
+      fprintf (stream, "DURATION:PT0H0M%ldS\n", rapt->dur);
+      fprintf (stream, "RRULE:FREQ=%s;INTERVAL=%d",
+               ical_recur_type[rapt->rpt->type], rapt->rpt->freq);
+
+      if (rapt->rpt->until != 0)
+        {
+          date_sec2date_fmt (rapt->rpt->until + HOURINSEC, ICALDATEFMT,
+                             ical_date);
+          fprintf (stream, ";UNTIL=%s\n", ical_date);
+        }
+      else
+        fputc ('\n', stream);
+
+      if (LLIST_FIRST (&rapt->exc))
+        {
+          fputs ("EXDATE:", stream);
+          LLIST_FOREACH (&rapt->exc, j)
+            {
+              struct excp *exc = LLIST_GET_DATA (j);
+              date_sec2date_fmt (exc->st, ICALDATEFMT, ical_date);
+              fprintf (stream, "%s", ical_date);
+              if (LLIST_NEXT (j))
+                fputc (',', stream);
+              else
+                fputc ('\n', stream);
+            }
+        }
+
+      fprintf (stream, "SUMMARY:%s\n", rapt->mesg);
+      if (rapt->state & APOINT_NOTIFY)
+        ical_export_valarm (stream);
+      fputs ("END:VEVENT\n", stream);
+    }
+  LLIST_TS_UNLOCK (&recur_alist_p);
+}
+
+/* Export appointments. */
+static void
+ical_export_apoints (FILE *stream)
+{
+  llist_item_t *i;
+  char ical_datetime[BUFSIZ];
+
+  LLIST_TS_LOCK (&alist_p);
+  LLIST_TS_FOREACH (&alist_p, i)
+    {
+      struct apoint *apt = LLIST_TS_GET_DATA (i);
+      date_sec2date_fmt (apt->start, ICALDATETIMEFMT, ical_datetime);
+      fputs ("BEGIN:VEVENT\n", stream);
+      fprintf (stream, "DTSTART:%s\n", ical_datetime);
+      fprintf (stream, "DURATION:P%ldDT%ldH%ldM%ldS\n",
+               apt->dur / DAYINSEC,
+               (apt->dur / HOURINSEC) % DAYINHOURS,
+               (apt->dur / MININSEC) % HOURINMIN,
+               apt->dur % MININSEC);
+      fprintf (stream, "SUMMARY:%s\n", apt->mesg);
+      if (apt->state & APOINT_NOTIFY)
+        ical_export_valarm (stream);
+      fputs ("END:VEVENT\n", stream);
+    }
+  LLIST_TS_UNLOCK (&alist_p);
+}
+
+/* Export todo items. */
+static void
+ical_export_todo (FILE *stream)
+{
+  llist_item_t *i;
+
+  LLIST_FOREACH (&todolist, i)
+    {
+      struct todo *todo = LLIST_TS_GET_DATA (i);
+      if (todo->id < 0)  /* completed items */
+        continue;
+
+      fputs ("BEGIN:VTODO\n", stream);
+      fprintf (stream, "PRIORITY:%d\n", todo->id);
+      fprintf (stream, "SUMMARY:%s\n", todo->mesg);
+      fputs ("END:VTODO\n", stream);
+    }
+}
+
+/* Print a header to describe import log report format. */
+static void
+ical_log_init (FILE *log, float version)
+{
+  const char *header =
+    "+-------------------------------------------------------------------+\n"
+    "| Calcurse icalendar import log.                                    |\n"
+    "|                                                                   |\n"
+    "| Items imported from icalendar file, version %1.1f                   |\n"
+    "| Some items could not be imported, they are described hereafter.   |\n"
+    "| The log line format is as follows:                                |\n"
+    "|                                                                   |\n"
+    "|       TYPE [LINE]: DESCRIPTION                                    |\n"
+    "|                                                                   |\n"
+    "| where:                                                            |\n"
+    "|  * TYPE represents the item type ('VEVENT' or 'VTODO')            |\n"
+    "|  * LINE is the line in the input stream at which this item begins |\n"
+    "|  * DESCRIPTION indicates why the item could not be imported       |\n"
+    "+-------------------------------------------------------------------+\n\n";
+
+  if (log)
+    fprintf (log, header, version);
+}
+
+/*
+ * Used to build a report of the import process.
+ * The icalendar item for which a problem occurs is mentioned (by giving its
+ * first line inside the icalendar file), together with a message describing the
+ * problem.
+ */
+static void
+ical_log (FILE *log, ical_types_e type, unsigned lineno, char *msg)
+{
+  const char *typestr[ICAL_TYPES] = {"VEVENT", "VTODO"};
+
+  RETURN_IF (type < 0 || type >= ICAL_TYPES, _("unknown ical type"));
+  if (log)
+    fprintf (log, "%s [%d]: %s\n", typestr[type], lineno, msg);
+}
+
+static void
+ical_store_todo (int priority, char *mesg, char *note)
+{
+  todo_add (mesg, priority, note);
+  mem_free (mesg);
+  erase_note (&note);
+}
+
+static void
+ical_store_event (char *mesg, char *note, long day, long end, ical_rpt_t *rpt,
+                  llist_t *exc)
+{
+  const int EVENTID = 1;
+
+  if (rpt)
+    {
+      recur_event_new (mesg, note, day, EVENTID, rpt->type, rpt->freq,
+                       rpt->until, exc);
+      mem_free (rpt);
+    }
+  else if (end && end != day)
+    {
+      /* Here we have an event that spans over several days. */
+      rpt = mem_malloc (sizeof (ical_rpt_t));
+      rpt->type = RECUR_DAILY;
+      rpt->freq = 1;
+      rpt->count = 0;
+      rpt->until = end;
+      recur_event_new (mesg, note, day, EVENTID, rpt->type, rpt->freq,
+                       rpt->until, exc);
+      mem_free (rpt);
+    }
+  else
+    {
+      event_new (mesg, note, day, EVENTID);
+    }
+  mem_free (mesg);
+  erase_note (&note);
+}
+
+static void
+ical_store_apoint (char *mesg, char *note, long start, long dur,
+                   ical_rpt_t *rpt, llist_t *exc, int has_alarm)
+{
+  char state = 0L;
+
+  if (has_alarm)
+    state |= APOINT_NOTIFY;
+  if (rpt)
+    {
+      recur_apoint_new (mesg, note, start, dur, state, rpt->type, rpt->freq,
+                        rpt->until, exc);
+      mem_free (rpt);
+    }
+  else
+    {
+      apoint_new (mesg, note, start, dur, state);
+    }
+  mem_free (mesg);
+  erase_note (&note);
+}
+
+/*
+ * Returns an allocated string representing the string given in argument once
+ * unformatted.
+ *
+ * Note:
+ * Even if the RFC2445 recommends not to have more than 75 octets on one line of
+ * text, I prefer not to restrict the parsing to this size, thus I use a buffer
+ * of size BUFSIZ.
+ *
+ * Extract from RFC2445:
+ * Lines of text SHOULD NOT be longer than 75 octets, excluding the line
+ * break.
+ */
+static char *
+ical_unformat_line (char *line)
+{
+  char *p, uline[BUFSIZ];
+  int len;
+
+  if (strlen (line) >= BUFSIZ)
+    return NULL;
+
+  bzero (uline, BUFSIZ);
+  for (len = 0, p = line; *p; p++)
+    {
+      switch (*p)
+        {
+        case '\\':
+          switch (*(p + 1))
+            {
+            case 'n':
+              uline[len++] = '\n';
+              p++;
+              break;
+            case 't':
+              uline[len++] = '\t';
+              p++;
+              break;
+            case ';':
+            case ':':
+            case ',':
+              uline[len++] = *(p + 1);
+              p++;
+              break;
+            default:
+              uline[len++] = *p;
+              break;
+            }
+          break;
+        default:
+          uline[len++] = *p;
+          break;
+        }
+    }
+
+  return mem_strdup (uline);
+}
+
+static void
+ical_readline_init (FILE *fdi, char *buf, char *lstore, unsigned *ln)
+{
+  char *eol;
+
+  *buf = *lstore = '\0';
+  fgets (lstore, BUFSIZ, fdi);
+  if ((eol = strchr(lstore, '\n')) != NULL)
+    *eol = '\0';
+  (*ln)++;
+}
+
+static int
+ical_readline (FILE *fdi, char *buf, char *lstore, unsigned *ln)
+{
+  char *eol;
+
+  strncpy (buf, lstore, BUFSIZ);
+  (*ln)++;
+
+  while (fgets (lstore, BUFSIZ, fdi) != NULL)
+    {
+      if ((eol = strchr(lstore, '\n')) != NULL)
+        *eol = '\0';
+      if (*lstore != SPACE && *lstore != TAB)
+        break;
+      strncat (buf, lstore + 1, BUFSIZ);
+      buf[BUFSIZ - 1] = '\0';
+      (*ln)++;
+    }
+
+  if (feof (fdi))
+    {
+      *lstore = '\0';
+      if (*buf == '\0')
+        return 0;
+    }
+
+  return 1;
+}
+
+static float
+ical_chk_header (FILE *fd, char *buf, char *lstore, unsigned *lineno)
+{
+  const int HEADER_MALFORMED = -1;
+  const struct string icalheader = STRING_BUILD ("BEGIN:VCALENDAR");
+  float version;
+
+  if (!ical_readline (fd, buf, lstore, lineno))
+    return HEADER_MALFORMED;
+
+  str_toupper (buf);
+  if (strncmp (buf, icalheader.str, icalheader.len) != 0)
+    return HEADER_MALFORMED;
+
+  while (!sscanf (buf, "VERSION:%f", &version))
+    {
+      if (!ical_readline (fd, buf, lstore, lineno))
+        return HEADER_MALFORMED;
+    }
+  return version;
+}
+
+/*
+ * iCalendar date-time format is based on the ISO 8601 complete
+ * representation. It should be something like : DATE 'T' TIME
+ * where DATE is 'YYYYMMDD' and TIME is 'HHMMSS'.
+ * The time and 'T' separator are optional (in the case of an day-long event).
+ *
+ * Optionnaly, if the type pointer is given, specify if it is an event
+ * (no time is given, meaning it is an all-day event), or an appointment
+ * (time is given).
+ *
+ * The timezone is not yet handled by calcurse.
+ */
+static long
+ical_datetime2long (char *datestr, ical_vevent_e *type)
+{
+  const int NOTFOUND = 0, FORMAT_DATE = 3, FORMAT_DATETIME = 5;
+  struct date date;
+  unsigned hour, min;
+  long datelong;
+  int format;
+
+  format = sscanf (datestr, "%04u%02u%02uT%02u%02u",
+                   &date.yyyy, &date.mm, &date.dd, &hour, &min);
+  if (format == FORMAT_DATE)
+    {
+      if (type)
+        *type = EVENT;
+      datelong = date2sec (date, 0, 0);
+    }
+  else if (format == FORMAT_DATETIME)
+    {
+      if (type)
+        *type = APPOINTMENT;
+      datelong = date2sec (date, hour, min);
+    }
+  else
+    {
+      datelong = NOTFOUND;
+    }
+  return datelong;
+}
+
+static long
+ical_durtime2long (char *timestr)
+{
+  long timelong;
+  char *p;
+
+  if ((p = strchr (timestr, 'T')) == NULL)
+    timelong = 0;
+  else
+    {
+      int nbmatch;
+      struct {
+        unsigned hour, min, sec;
+      } time;
+
+      p++;
+      bzero (&time, sizeof time);
+      nbmatch = sscanf (p, "%uH%uM%uS", &time.hour, &time.min, &time.sec);
+      if (nbmatch < 1 || nbmatch > 3)
+        timelong = 0;
+      else
+        timelong = time.hour * HOURINSEC + time.min * MININSEC + time.sec;
+    }
+  return timelong;
+}
+
+/*
+ * Extract from RFC2445:
+ *
+ * Value Name: DURATION
+ *
+ * Purpose: This value type is used to identify properties that contain
+ * duration of time.
+ *
+ * Formal Definition: The value type is defined by the following
+ * notation:
+ *
+ * dur-value  = (["+"] / "-") "P" (dur-date / dur-time / dur-week)
+ * dur-date   = dur-day [dur-time]
+ * dur-time   = "T" (dur-hour / dur-minute / dur-second)
+ * dur-week   = 1*DIGIT "W"
+ * dur-hour   = 1*DIGIT "H" [dur-minute]
+ * dur-minute = 1*DIGIT "M" [dur-second]
+ * dur-second = 1*DIGIT "S"
+ * dur-day    = 1*DIGIT "D"
+ *
+ * Example: A duration of 15 days, 5 hours and 20 seconds would be:
+ * P15DT5H0M20S
+ * A duration of 7 weeks would be:
+ * P7W
+ */
+static long
+ical_dur2long (char *durstr)
+{
+  const int NOTFOUND = -1;
+  long durlong;
+  char *p;
+  struct {
+    unsigned week, day;
+  } date;
+
+  bzero (&date, sizeof date);
+  if ((p = strchr (durstr, 'P')) == NULL)
+    durlong = NOTFOUND;
+  else
+    {
+      p++;
+      if (*p == '-')
+        return NOTFOUND;
+      else if (*p == '+')
+        p++;
+
+      if (*p == 'T')                                      /* dur-time */
+        durlong = ical_durtime2long (p);
+      else if (strchr (p, 'W'))                           /* dur-week */
+        {
+          if (sscanf (p, "%u", &date.week) == 1)
+            durlong = date.week * WEEKINDAYS * DAYINSEC;
+          else
+            durlong = NOTFOUND;
+        }
+      else
+        {
+          if (strchr (p, 'D'))                            /* dur-date */
+            {
+              if (sscanf (p, "%uD", &date.day) == 1)
+                {
+                  durlong = date.day * DAYINSEC;
+                  durlong += ical_durtime2long (p);
+                }
+              else
+                durlong = NOTFOUND;
+            }
+          else
+            durlong = NOTFOUND;
+        }
+    }
+  return durlong;
+}
+
+/*
+ * Compute the vevent repetition end date from the repetition count.
+ *
+ * Extract from RFC2445:
+ * The COUNT rule part defines the number of occurrences at which to
+ * range-bound the recurrence. The "DTSTART" property value, if specified,
+ * counts as the first occurrence.
+ */
+static long
+ical_compute_rpt_until (long start, ical_rpt_t *rpt)
+{
+  long until;
+
+  switch (rpt->type)
+    {
+    case RECUR_DAILY:
+      until = date_sec_change (start, 0,  rpt->freq * (rpt->count - 1));
+      break;
+    case RECUR_WEEKLY:
+      until = date_sec_change (start, 0,
+                               rpt->freq * WEEKINDAYS * (rpt->count - 1));
+      break;
+    case RECUR_MONTHLY:
+      until = date_sec_change (start, rpt->freq * (rpt->count - 1), 0);
+      break;
+    case RECUR_YEARLY:
+      until = date_sec_change (start, rpt->freq * 12 * (rpt->count - 1), 0);
+      break;
+    default:
+      until = 0;
+      break;
+      /* NOTREACHED */
+    }
+  return until;
+}
+
+/*
+ * Read a recurrence rule from an iCalendar RRULE string.
+ *
+ * Value Name: RECUR
+ *
+ * Purpose: This value type is used to identify properties that contain
+ * a recurrence rule specification.
+ *
+ * Formal Definition: The value type is defined by the following
+ * notation:
+ *
+ * recur      = "FREQ"=freq *(
+ *
+ * ; either UNTIL or COUNT may appear in a 'recur',
+ * ; but UNTIL and COUNT MUST NOT occur in the same 'recur'
+ *
+ * ( ";" "UNTIL" "=" enddate ) /
+ * ( ";" "COUNT" "=" 1*DIGIT ) /
+ *
+ * ; the rest of these keywords are optional,
+ * ; but MUST NOT occur more than
+ * ; once
+ *
+ * ( ";" "INTERVAL" "=" 1*DIGIT )          /
+ * ( ";" "BYSECOND" "=" byseclist )        /
+ * ( ";" "BYMINUTE" "=" byminlist )        /
+ * ( ";" "BYHOUR" "=" byhrlist )           /
+ * ( ";" "BYDAY" "=" bywdaylist )          /
+ * ( ";" "BYMONTHDAY" "=" bymodaylist )    /
+ * ( ";" "BYYEARDAY" "=" byyrdaylist )     /
+ * ( ";" "BYWEEKNO" "=" bywknolist )       /
+ * ( ";" "BYMONTH" "=" bymolist )          /
+ * ( ";" "BYSETPOS" "=" bysplist )         /
+ * ( ";" "WKST" "=" weekday )              /
+ * ( ";" x-name "=" text )
+ * )
+*/
+static ical_rpt_t *
+ical_read_rrule (FILE *log, char *rrulestr, unsigned *noskipped,
+                 const int itemline)
+{
+  const struct string daily = STRING_BUILD ("DAILY");
+  const struct string weekly = STRING_BUILD ("WEEKLY");
+  const struct string monthly = STRING_BUILD ("MONTHLY");
+  const struct string yearly = STRING_BUILD ("YEARLY");
+  const struct string count = STRING_BUILD ("COUNT=");
+  const struct string interv = STRING_BUILD ("INTERVAL=");
+  unsigned interval;
+  ical_rpt_t *rpt;
+  char *p;
+
+  rpt = NULL;
+  if ((p = strchr (rrulestr, ':')) != NULL)
+    {
+      char freqstr[BUFSIZ];
+
+      p++;
+      rpt = mem_malloc (sizeof (ical_rpt_t));
+      bzero (rpt, sizeof (ical_rpt_t));
+      if (sscanf (p, "FREQ=%s", freqstr) != 1)
+        {
+          ical_log (log, ICAL_VEVENT, itemline,
+                    _("recurrence frequence not found."));
+          (*noskipped)++;
+          mem_free (rpt);
+          return NULL;
+        }
+      else
+        {
+          if (strncmp (freqstr, daily.str, daily.len) == 0)
+            rpt->type = RECUR_DAILY;
+          else if (strncmp (freqstr, weekly.str, weekly.len) == 0)
+            rpt->type = RECUR_WEEKLY;
+          else if (strncmp (freqstr, monthly.str, monthly.len) == 0)
+            rpt->type = RECUR_MONTHLY;
+          else if (strncmp (freqstr, yearly.str, yearly.len) == 0)
+            rpt->type = RECUR_YEARLY;
+          else
+            {
+              ical_log (log, ICAL_VEVENT, itemline,
+                        _("recurrence frequence not recognized."));
+              (*noskipped)++;
+              mem_free (rpt);
+              return NULL;
+            }
+        }
+      /*
+        The UNTIL rule part defines a date-time value which bounds the
+        recurrence rule in an inclusive manner.  If not present, and the
+        COUNT rule part is also not present, the RRULE is considered to
+        repeat forever.
+
+        The COUNT rule part defines the number of occurrences at which to
+        range-bound the recurrence.  The "DTSTART" property value, if
+        specified, counts as the first occurrence.
+      */
+      if ((p = strstr (rrulestr, "UNTIL")) != NULL)
+        {
+          char *untilstr;
+
+          untilstr = strchr (p, '=');
+          rpt->until = ical_datetime2long (++untilstr, NULL);
+        }
+      else
+        {
+          unsigned cnt;
+          char *countstr;
+
+          if ((countstr = strstr (rrulestr, count.str)) != NULL)
+            {
+              countstr += count.len;
+              if (sscanf (countstr, "%u", &cnt) != 1)
+                {
+                  rpt->until = 0;
+                  /* endless repetition */
+                }
+              else
+                {
+                  rpt->count = cnt;
+                }
+            }
+          else
+            rpt->until = 0;
+        }
+
+      if ((p = strstr (rrulestr, interv.str)) != NULL)
+        {
+          p += interv.len;
+          if (sscanf (p, "%u", &interval) != 1)
+            {
+              rpt->freq = 1;
+              /* default frequence if none specified */
+            }
+          else
+            {
+              rpt->freq = interval;
+            }
+        }
+      else
+        {
+          rpt->freq = 1;
+        }
+    }
+  else
+    {
+      ical_log (log, ICAL_VEVENT, itemline, _("recurrence rule malformed."));
+      (*noskipped)++;
+    }
+  return rpt;
+}
+
+static void
+ical_add_exc (llist_t *exc_head, long date)
+{
+  if (date != 0)
+    {
+      struct excp *exc = mem_malloc (sizeof (struct excp));
+      exc->st = date;
+
+      LLIST_ADD (exc_head, exc);
+    }
+}
+
+/*
+ * This property defines the list of date/time exceptions for a
+ * recurring calendar component.
+ */
+void
+ical_read_exdate (llist_t *exc, FILE *log, char *exstr, unsigned *noskipped,
+                  const int itemline)
+{
+  char *p, *q;
+  long date;
+
+  LLIST_INIT (exc);
+  if ((p = strchr (exstr, ':')) != NULL)
+    {
+      p++;
+      while ((q = strchr (p, ',')) != NULL)
+        {
+          char buf[BUFSIZ];
+          const int buflen = q - p;
+
+          strncpy (buf, p, buflen);
+          buf[buflen] = '\0';
+          date = ical_datetime2long (buf, NULL);
+          ical_add_exc (exc, date);
+          p = ++q;
+        }
+      date = ical_datetime2long (p, NULL);
+      ical_add_exc (exc, date);
+    }
+  else
+    {
+      ical_log (log, ICAL_VEVENT, itemline,
+                _("recurrence exception dates malformed."));
+      (*noskipped)++;
+    }
+}
+
+/* Return an allocated string containing the name of the newly created note. */
+static char *
+ical_read_note (char *line, unsigned *noskipped, ical_vevent_e item_type,
+                const int itemline, FILE *log)
+{
+  char *sha1 = mem_malloc (SHA1_DIGESTLEN * 2 + 1);
+  char *p, *notestr, fullnotename[BUFSIZ];
+  FILE *fdo;
+
+  if ((p = strchr (line, ':')) != NULL)
+    {
+      p++;
+      notestr = ical_unformat_line (p);
+      if (notestr == NULL)
+        {
+          ical_log (log, item_type, itemline,
+                    _("could not get entire item description."));
+          (*noskipped)++;
+          return NULL;
+        }
+      else if (strlen (notestr) == 0)
+        {
+          mem_free (notestr);
+          return NULL;
+        }
+      else
+        {
+          sha1_digest (notestr, sha1);
+          snprintf (fullnotename, BUFSIZ, "%s%s", path_notes, sha1);
+          fdo = fopen (fullnotename, "w");
+          EXIT_IF (fdo == NULL, _("Warning: could not open %s, Aborting..."),
+                   fullnotename);
+          fprintf (fdo, "%s", notestr);
+          file_close (fdo, __FILE_POS__);
+          mem_free (notestr);
+          return sha1;
+        }
+    }
+  else
+    {
+      ical_log (log, item_type, itemline, _("description malformed."));
+      (*noskipped)++;
+      return NULL;
+    }
+}
+
+/* Returns an allocated string containing the ical item summary. */
+static char *
+ical_read_summary (char *line)
+{
+  char *p, *summary;
+
+  if ((p = strchr (line, ':')) != NULL)
+    {
+      p++;
+      summary = ical_unformat_line (p);
+      return summary;
+    }
+  else
+    return NULL;
+}
+
+static void
+ical_read_event (FILE *fdi, FILE *log, unsigned *noevents, unsigned *noapoints,
+                 unsigned *noskipped, char *buf, char *lstore,
+                 unsigned *lineno)
+{
+  const int ITEMLINE = *lineno;
+  const struct string endevent = STRING_BUILD ("END:VEVENT");
+  const struct string summary  = STRING_BUILD ("SUMMARY");
+  const struct string dtstart  = STRING_BUILD ("DTSTART");
+  const struct string dtend    = STRING_BUILD ("DTEND");
+  const struct string duration = STRING_BUILD ("DURATION");
+  const struct string rrule    = STRING_BUILD ("RRULE");
+  const struct string exdate   = STRING_BUILD ("EXDATE");
+  const struct string alarm    = STRING_BUILD ("BEGIN:VALARM");
+  const struct string endalarm = STRING_BUILD ("END:VALARM");
+  const struct string desc     = STRING_BUILD ("DESCRIPTION");
+  ical_vevent_e vevent_type;
+  char *p, buf_upper[BUFSIZ];
+  struct {
+    llist_t       exc;
+    ical_rpt_t   *rpt;
+    char         *mesg, *note;
+    long          start, end, dur;
+    int           has_alarm;
+  } vevent;
+  int skip_alarm;
+
+  vevent_type = UNDEFINED;
+  bzero (&vevent, sizeof vevent);
+  skip_alarm = 0;
+  while (ical_readline (fdi, buf, lstore, lineno))
+    {
+      strncpy (buf_upper, buf, BUFSIZ);
+      buf_upper[BUFSIZ - 1] = '\0';
+      str_toupper (buf_upper);
+
+      if (skip_alarm)
+        {
+          /* Need to skip VALARM properties because some keywords could
+             interfere, such as DURATION, SUMMARY,.. */
+          if (strncmp (buf_upper, endalarm.str, endalarm.len) == 0)
+            skip_alarm = 0;
+          continue;
+        }
+      if (strncmp (buf_upper, endevent.str, endevent.len) == 0)
+        {
+          if (vevent.mesg)
+            {
+              if (vevent.rpt && vevent.rpt->count)
+                vevent.rpt->until = ical_compute_rpt_until (vevent.start,
+                                                            vevent.rpt);
+
+              switch (vevent_type)
+                {
+                case APPOINTMENT:
+                  if (vevent.start == 0)
+                    {
+                      ical_log (log, ICAL_VEVENT, ITEMLINE,
+                                _("appointment has no start time."));
+                      goto cleanup;
+                    }
+                  if (vevent.dur == 0)
+                    {
+                      if (vevent.end == 0)
+                        {
+                          ical_log (log, ICAL_VEVENT, ITEMLINE,
+                                    _("could not compute duration "
+                                    "(no end time)."));
+                          goto cleanup;
+                        }
+                      else if (vevent.start == vevent.end)
+                        {
+                          vevent_type = EVENT;
+                          vevent.end = 0L;
+                          ical_store_event (vevent.mesg, vevent.note,
+                                            vevent.start, vevent.end,
+                                            vevent.rpt, &vevent.exc);
+                          (*noevents)++;
+                          return;
+                        }
+                      else
+                        {
+                          vevent.dur = vevent.end - vevent.start;
+                          if (vevent.dur < 0)
+                            {
+                              ical_log (log, ICAL_VEVENT, ITEMLINE,
+                                        _("item has a negative duration."));
+                              goto cleanup;
+                            }
+                        }
+                    }
+                  ical_store_apoint (vevent.mesg, vevent.note, vevent.start,
+                                     vevent.dur, vevent.rpt, &vevent.exc,
+                                     vevent.has_alarm);
+                  (*noapoints)++;
+                  break;
+                case EVENT:
+                  if (vevent.start == 0)
+                    {
+                      ical_log (log, ICAL_VEVENT, ITEMLINE,
+                                _("event date is not defined."));
+                      goto cleanup;
+                    }
+                  ical_store_event (vevent.mesg, vevent.note, vevent.start,
+                                    vevent.end, vevent.rpt, &vevent.exc);
+                  (*noevents)++;
+                  break;
+                case UNDEFINED:
+                  ical_log (log, ICAL_VEVENT, ITEMLINE,
+                            _("item could not be identified."));
+                  goto cleanup;
+                  break;
+                }
+            }
+          else
+            {
+              ical_log (log, ICAL_VEVENT, ITEMLINE,
+                        _("could not retrieve item summary."));
+              goto cleanup;
+            }
+          return;
+        }
+      else
+        {
+          if (strncmp (buf_upper, dtstart.str, dtstart.len) == 0)
+            {
+              if ((p = strchr (buf, ':')) != NULL)
+                vevent.start = ical_datetime2long (++p, &vevent_type);
+              if (!vevent.start)
+                {
+                  ical_log (log, ICAL_VEVENT, ITEMLINE,
+                            _("could not retrieve event start time."));
+                  goto cleanup;
+                }
+            }
+          else if (strncmp (buf_upper, dtend.str, dtend.len) == 0)
+            {
+              if ((p = strchr (buf, ':')) != NULL)
+                vevent.end = ical_datetime2long (++p, &vevent_type);
+              if (!vevent.end)
+                {
+                  ical_log (log, ICAL_VEVENT, ITEMLINE,
+                            _("could not retrieve event end time."));
+                  goto cleanup;
+                }
+            }
+          else if (strncmp (buf_upper, duration.str, duration.len) == 0)
+            {
+              if ((vevent.dur = ical_dur2long (buf)) <= 0)
+                {
+                  ical_log (log, ICAL_VEVENT, ITEMLINE,
+                           _("item duration malformed."));
+                  goto cleanup;
+                }
+            }
+          else if (strncmp (buf_upper, rrule.str, rrule.len) == 0)
+            {
+              vevent.rpt = ical_read_rrule (log, buf, noskipped, ITEMLINE);
+            }
+          else if (strncmp (buf_upper, exdate.str, exdate.len) == 0)
+            {
+              ical_read_exdate (&vevent.exc, log, buf, noskipped, ITEMLINE);
+            }
+          else if (strncmp (buf_upper, summary.str, summary.len) == 0)
+            {
+              vevent.mesg = ical_read_summary (buf);
+            }
+          else if (strncmp (buf_upper, alarm.str, alarm.len) == 0)
+            {
+              skip_alarm = 1;
+              vevent.has_alarm = 1;
+            }
+          else if (strncmp (buf_upper, desc.str, desc.len) == 0)
+            {
+              vevent.note = ical_read_note (buf, noskipped, ICAL_VEVENT,
+                                            ITEMLINE, log);
+            }
+        }
+    }
+  ical_log (log, ICAL_VEVENT, ITEMLINE,
+            _("The ical file seems to be malformed. "
+            "The end of item was not found."));
+
+cleanup:
+
+  if (vevent.note)
+    mem_free (vevent.note);
+  if (vevent.mesg)
+    mem_free (vevent.mesg);
+  if (vevent.rpt)
+    mem_free (vevent.rpt);
+  LLIST_FREE (&vevent.exc);
+  (*noskipped)++;
+}
+
+static void
+ical_read_todo (FILE *fdi, FILE *log, unsigned *notodos, unsigned *noskipped,
+                char *buf, char *lstore, unsigned *lineno)
+{
+  const struct string endtodo  = STRING_BUILD ("END:VTODO");
+  const struct string summary  = STRING_BUILD ("SUMMARY");
+  const struct string alarm    = STRING_BUILD ("BEGIN:VALARM");
+  const struct string endalarm = STRING_BUILD ("END:VALARM");
+  const struct string desc     = STRING_BUILD ("DESCRIPTION");
+  const int LOWEST = 9;
+  const int ITEMLINE = *lineno;
+  char buf_upper[BUFSIZ];
+  struct {
+    char *mesg, *note;
+    int has_priority, priority;
+  } vtodo;
+  int skip_alarm;
+
+  bzero (&vtodo, sizeof vtodo);
+  skip_alarm = 0;
+  while (ical_readline (fdi, buf, lstore, lineno))
+    {
+      strncpy (buf_upper, buf, BUFSIZ);
+      buf_upper[BUFSIZ - 1] = '\0';
+      str_toupper (buf_upper);
+      if (skip_alarm)
+        {
+          /* Need to skip VALARM properties because some keywords could
+             interfere, such as DURATION, SUMMARY,.. */
+          if (strncmp (buf_upper, endalarm.str, endalarm.len) == 0)
+            skip_alarm = 0;
+          continue;
+        }
+      if (strncmp (buf_upper, endtodo.str, endtodo.len) == 0)
+        {
+          if (!vtodo.has_priority)
+            vtodo.priority = LOWEST;
+          if (vtodo.mesg)
+            {
+              ical_store_todo (vtodo.priority, vtodo.mesg, vtodo.note);
+              (*notodos)++;
+            }
+          else
+            {
+              ical_log (log, ICAL_VTODO, ITEMLINE,
+                        _("could not retrieve item summary."));
+              goto cleanup;
+            }
+          return;
+        }
+      else
+        {
+          int tmpint;
+
+          if (sscanf (buf_upper, "PRIORITY:%d", &tmpint) == 1)
+            {
+              if (tmpint <= 9 && tmpint >= 1)
+                {
+                  vtodo.priority = tmpint;
+                  vtodo.has_priority = 1;
+                }
+              else
+                {
+                  ical_log (log, ICAL_VTODO, ITEMLINE,
+                           _("item priority is not acceptable "
+                           "(must be between 1 and 9)."));
+                  vtodo.priority = LOWEST;
+                }
+            }
+          else if (strncmp (buf_upper, summary.str, summary.len) == 0)
+            {
+              vtodo.mesg = ical_read_summary (buf);
+            }
+          else if (strncmp (buf_upper, alarm.str, alarm.len) == 0)
+            {
+              skip_alarm = 1;
+            }
+          else if (strncmp (buf_upper, desc.str, desc.len) == 0)
+            {
+              vtodo.note = ical_read_note (buf, noskipped, ICAL_VTODO,
+                                           ITEMLINE, log);
+            }
+        }
+    }
+  ical_log (log, ICAL_VTODO, ITEMLINE,
+            _("The ical file seems to be malformed. "
+            "The end of item was not found."));
+
+cleanup:
+
+  if (vtodo.note)
+    mem_free (vtodo.note);
+  if (vtodo.mesg)
+    mem_free (vtodo.mesg);
+  (*noskipped)++;
+}
+
+/* Import calcurse data. */
+void
+ical_import_data (FILE *stream, FILE *log, unsigned *events, unsigned *apoints,
+                  unsigned *todos, unsigned *lines, unsigned *skipped)
+{
+  const struct string vevent = STRING_BUILD ("BEGIN:VEVENT");
+  const struct string vtodo = STRING_BUILD ("BEGIN:VTODO");
+  char buf[BUFSIZ], lstore[BUFSIZ];
+  float ical_version;
+
+  ical_readline_init (stream, buf, lstore, lines);
+  ical_version = ical_chk_header (stream, buf, lstore, lines);
+  RETURN_IF (ical_version < 0,
+             _("Warning: ical header malformed or wrong version number. "
+               "Aborting..."));
+
+  ical_log_init (log, ical_version);
+
+  while (ical_readline (stream, buf, lstore, lines))
+    {
+      (*lines)++;
+      str_toupper (buf);
+      if (strncmp (buf, vevent.str, vevent.len) == 0)
+        {
+          ical_read_event (stream, log, events, apoints, skipped, buf, lstore,
+                           lines);
+        }
+      else if (strncmp (buf, vtodo.str, vtodo.len) == 0)
+        {
+          ical_read_todo (stream, log, todos, skipped, buf, lstore, lines);
+        }
+    }
+}
+
+/* Export calcurse data. */
+void
+ical_export_data (FILE *stream)
+{
+  ical_export_header (stream);
+  ical_export_recur_events (stream);
+  ical_export_events (stream);
+  ical_export_recur_apoints (stream);
+  ical_export_apoints (stream);
+  ical_export_todo (stream);
+  ical_export_footer (stream);
+}