isync/maildir.c

/* $Id$
 *
 * isync - IMAP4 to maildir mailbox synchronizer
 * Copyright (C) 2000-1 Michael R. Elkins <me@mutt.org>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <dirent.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <errno.h>
#include <time.h>
#include "isync.h"

static int
do_lock (int fd, int flag)
{
    struct flock lck;
    struct stat sb;

    if (fstat (fd, &sb))
    {
	perror ("fstat");
	return -1;
    }

    memset (&lck, 0, sizeof (lck));
    lck.l_type = flag;
    lck.l_whence = SEEK_SET;
    lck.l_start = 0;
    lck.l_len = sb.st_size;

    if (fcntl (fd, F_SETLK, &lck))
    {
	perror ("fcntl");
	close (fd);
	return -1;
    }

    return 0;
}

/* 2,<flags> */
static void
parse_info (message_t * m, char *s)
{
    if (*s == '2' && *(s + 1) == ',')
    {
	s += 2;
	while (*s)
	{
	    if (*s == 'F')
		m->flags |= D_FLAGGED;
	    else if (*s == 'R')
		m->flags |= D_ANSWERED;
	    else if (*s == 'T')
		m->flags |= D_DELETED;
	    else if (*s == 'S')
		m->flags |= D_SEEN;
	    s++;
	}
    }
}

static unsigned int
read_uid (const char *path, const char *file)
{
    char full[_POSIX_PATH_MAX];
    int fd;
    int ret;
    int len;
    char buf[64];
    unsigned int uid = 0;

    snprintf (full, sizeof (full), "%s/%s", path, file);
    fd = open (full, O_RDONLY);
    if (fd == -1)
    {
	if (errno != ENOENT)
	{
	    perror ("open");
	    return -1;
	}
	return 0;		/* doesn't exist */
    }
    ret = do_lock (fd, F_RDLCK);
    if (!ret)
    {
	len = read (fd, buf, sizeof (buf) - 1);
	if (len == -1)
	    ret = -1;
	else
	{
	    buf[len] = 0;
	    uid = atol (buf);
	}
    }
    ret |= do_lock (fd, F_UNLCK);
    close (fd);
    return ret ? (unsigned int) ret : uid;

}

/* open a maildir mailbox.  if `fast' is nonzero, we just check to make
 * sure its a valid mailbox and don't actually parse it.  any IMAP messages
 * with the \Recent flag set are guaranteed not to be in the mailbox yet,
 * so we can save a lot of time when the user just wants to fetch new messages
 * without syncing the flags.
 */
mailbox_t *
maildir_open (const char *path, int fast)
{
    char buf[_POSIX_PATH_MAX];
    DIR *d;
    struct dirent *e;
    message_t **cur;
    message_t *p;
    mailbox_t *m;
    char *s;
    int count = 0;

    m = calloc (1, sizeof (mailbox_t));
    /* filename expansion happens here, not in the config parser */
    m->path = expand_strdup (path);

    /* check to make sure this looks like a valid maildir box */
    snprintf (buf, sizeof (buf), "%s/new", m->path);
    if (access (buf, F_OK))
    {
	free (m->path);
	free (m);
	perror ("access");
	return 0;
    }
    snprintf (buf, sizeof (buf), "%s/cur", m->path);
    if (access (buf, F_OK))
    {
	free (m->path);
	free (m);
	perror ("access");
	return 0;
    }

    /* check for the uidvalidity value */
    m->uidvalidity = read_uid (m->path, "isyncuidvalidity");
    if (m->uidvalidity == (unsigned int) -1)
    {
	free (m->path);
	free (m);
	return NULL;
    }

    /* load the current maxuid */
    if ((m->maxuid = read_uid (m->path, "isyncmaxuid")) == (unsigned int) -1)
    {
	free (m->path);
	free (m);
	return NULL;
    }

    if (fast)
	return m;

    cur = &m->msgs;
    for (; count < 2; count++)
    {
	/* read the msgs from the new subdir */
	snprintf (buf, sizeof (buf), "%s/%s", m->path,
		  (count == 0) ? "new" : "cur");
	d = opendir (buf);
	if (!d)
	{
	    free (m->path);
	    free (m);
	    perror ("opendir");
	    return 0;
	}
	while ((e = readdir (d)))
	{
	    if (*e->d_name == '.')
		continue;	/* skip dot-files */
	    *cur = calloc (1, sizeof (message_t));
	    p = *cur;
	    p->file = strdup (e->d_name);
	    p->uid = -1;
	    p->flags = 0;
	    p->new = (count == 0);

	    /* filename format is something like:
	     * <unique-prefix>,U=<n>:2,<flags>
	     * This is completely non-standard, but in order for mail
	     * clients to understand the flags, we have to use the
	     * standard :info as described by the qmail spec
	     */
	    s = strstr (p->file, ",U=");
	    if (!s)
		s = strstr (p->file, "UID");
	    if (!s)
		puts ("Warning, no UID for message");
	    else
	    {
		p->uid = strtol (s + 3, &s, 10);
		if (p->uid > m->maxuid)
		{
		    m->maxuid = p->uid;
		    m->maxuidchanged = 1;
		}
		/* Courier-IMAP names it files
		 * 	unique,S=<size>:info
		 * so we need to put the UID before the size, hence here
		 * we check for a comma as a valid terminator as well,
		 * since the format will be
		 * 	unique,U=<uid>,S=<size>:info
		 */
		if (*s && *s != ':' && *s != ',')
		{
		    puts ("Warning, unable to parse UID");
		    p->uid = -1;	/* reset */
		}
	    }

	    s = strchr (p->file, ':');
	    if (s)
		parse_info (p, s + 1);
	    if (p->flags & D_DELETED)
		m->deleted++;
	    cur = &p->next;
	}
	closedir (d);
    }
    return m;
}

/* permanently remove messages from a maildir mailbox.  if `dead' is nonzero,
 * we only remove the messags marked dead.
 */
int
maildir_expunge (mailbox_t * mbox, int dead)
{
    message_t **cur = &mbox->msgs;
    message_t *tmp;
    char path[_POSIX_PATH_MAX];

    while (*cur)
    {
	if ((dead == 0 && (*cur)->flags & D_DELETED) ||
	    (dead && (*cur)->dead))
	{
	    tmp = *cur;
	    *cur = (*cur)->next;
	    snprintf (path, sizeof (path), "%s/%s/%s",
		      mbox->path, tmp->new ? "new" : "cur", tmp->file);
	    if (unlink (path))
		perror ("unlink");
	    free (tmp->file);
	    free (tmp);
	}
	else
	    cur = &(*cur)->next;
    }
    return 0;
}

static int
update_maxuid (mailbox_t * mbox)
{
    int fd;
    char buf[64];
    size_t len;
    unsigned int uid;
    char path[_POSIX_PATH_MAX];
    int ret = 0;

    snprintf (path, sizeof (path), "%s/isyncmaxuid", mbox->path);
    fd = open (path, O_RDWR | O_CREAT, 0600);
    if (fd == -1)
    {
	perror ("open");
	return -1;
    }

    /* lock the file */
    if (do_lock (fd, F_WRLCK))
    {
	close (fd);
	return -1;
    }

    /* read the file again just to make sure it wasn't updated while
     * we were doing something else
     */
    len = read (fd, buf, sizeof (buf) - 1);
    buf[len] = 0;
    uid = atol (buf);
    if (uid > mbox->maxuid)
    {
	puts ("Error, maxuid is now higher (fatal)");
	ret = -1;
    }

    if (!ret)
    {
	/* rewind */
	lseek (fd, 0, SEEK_SET);

	/* write out the file */
	snprintf (buf, sizeof (buf), "%u\n", mbox->maxuid);
	len = write (fd, buf, strlen (buf));
	if (len == (size_t) - 1)
	{
	    perror ("write");
	    ret = -1;
	}
	else
	{
	    ret = ftruncate (fd, len);
	    if (ret)
		perror ("ftruncate");
	}
    }

    ret |= do_lock (fd, F_UNLCK);
    ret |= close (fd);

    return ret;
}

#define _24_HOURS (3600 * 24)

static void
maildir_clean_tmp (const char *mbox)
{
    char path[_POSIX_PATH_MAX];
    DIR *dirp;
    struct dirent *entry;
    struct stat info;
    time_t now;

    snprintf (path, sizeof (path), "%s/tmp", mbox);
    dirp = opendir (path);
    if (dirp == NULL)
    {
	fprintf (stderr, "maildir_clean_tmp: opendir: %s: %s (errno %d)\n", path, strerror (errno), errno);
	return;
    }
    /* assuming this scan will take less than a second, we only need to
     * check the time once before the following loop.
     */
    time (&now);
    while ((entry = readdir (dirp)))
    {
	snprintf (path, sizeof (path), "%s/tmp/%s", mbox, entry->d_name);
	if (stat (path, &info))
	    fprintf (stderr, "maildir_clean_tmp: stat: %s: %s (errno %d)\n", path, strerror (errno), errno);
	else if (S_ISREG (info.st_mode) && now - info.st_ctime >= _24_HOURS)
	{
	    /* this should happen infrequently enough that it won't be
	     * bothersome to the user to display when it occurs.
	     */
	    printf ("Warning: removing stale file %s\n", path);
	    if (unlink (path))
		fprintf (stderr, "maildir_clean_tmp: unlink: %s: %s (errno %d)\n", path, strerror (errno), errno);
	}
    }
}

int
maildir_close (mailbox_t * mbox)
{
    message_t *cur = mbox->msgs;
    char path[_POSIX_PATH_MAX];
    char oldpath[_POSIX_PATH_MAX];
    char *p;
    int ret = 0;

    if (mbox->changed)
    {
	for (; cur; cur = cur->next)
	{
	    if (cur->changed)
	    {
		/* generate old path */
		snprintf (oldpath, sizeof (oldpath), "%s/%s/%s",
			  mbox->path, cur->new ? "new" : "cur", cur->file);

		/* truncate old flags (if present) */
		p = strchr (cur->file, ':');
		if (p)
		    *p = 0;

		/* generate new path - always put this in the cur/ directory
		 * because its no longer new
		 */
		snprintf (path, sizeof (path), "%s/cur/%s:2,%s%s%s%s",
			  mbox->path,
			  cur->file, (cur->flags & D_FLAGGED) ? "F" : "",
			  (cur->flags & D_ANSWERED) ? "R" : "",
			  (cur->flags & D_SEEN) ? "S" : "",
			  (cur->flags & D_DELETED) ? "T" : "");

		if (rename (oldpath, path))
		    perror ("rename");
	    }
	}
    }

    if (mbox->maxuidchanged)
	ret = update_maxuid (mbox);

    /* per the maildir(5) specification, delivery agents are supposed to
     * set a 24-hour timer on items placed in the `tmp' directory.
     */
    maildir_clean_tmp (mbox->path);

    free (mbox->path);
    free_message (mbox->msgs);
    memset (mbox, 0xff, sizeof (mailbox_t));
    free (mbox);

    return ret;
}

int
maildir_set_uidvalidity (mailbox_t * mbox, unsigned int uidvalidity)
{
    char path[_POSIX_PATH_MAX];
    char buf[16];
    int fd;
    int ret;

    snprintf (path, sizeof (path), "%s/isyncuidvalidity", mbox->path);
    fd = open (path, O_WRONLY | O_CREAT | O_EXCL, 0600);
    if (fd == -1)
    {
	perror ("open");
	return -1;
    }
    snprintf (buf, sizeof (buf), "%u\n", uidvalidity);

    ret = write (fd, buf, strlen (buf));

    if (ret == -1)
	perror ("write");
    else if ((size_t) ret != strlen (buf))
	ret = -1;
    else
	ret = 0;

    if (close (fd))
    {
	perror ("close");
	ret = -1;
    }

    if (ret)
	if (unlink (path))
	    perror ("unlink");

    return (ret);
}