c121ec912f
the uid for each message in the maildir is now stored in a dbm database rather than the filename. this change was necessary because isync became confused if you copied a message to another folder, in which case the uid was invalid. as a result of the above change, isync now acquires a mutex on the mailbox to protect the dbm database from concurrent access. main() was reworked to continue gracefully when an error is encountered, and to always call maildir_close() so that the lock can be disabled, and the database closed.
512 lines
11 KiB
C
512 lines
11 KiB
C
/* $Id$
|
|
*
|
|
* isync - IMAP4 to maildir mailbox synchronizer
|
|
* Copyright (C) 2000-2 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 = 0;
|
|
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 (full);
|
|
return -1;
|
|
}
|
|
return 0; /* doesn't exist */
|
|
}
|
|
len = read (fd, buf, sizeof (buf) - 1);
|
|
if (len == -1)
|
|
{
|
|
perror ("read");
|
|
ret = -1;
|
|
}
|
|
else
|
|
{
|
|
buf[len] = 0;
|
|
uid = atol (buf);
|
|
}
|
|
close (fd);
|
|
return ret ? (unsigned int) ret : uid;
|
|
|
|
}
|
|
|
|
/* NOTE: this is NOT NFS safe */
|
|
static int
|
|
maildir_lock (mailbox_t * m)
|
|
{
|
|
char path[_POSIX_PATH_MAX];
|
|
|
|
snprintf (path, sizeof (path), "%s/isynclock", m->path);
|
|
m->lockfd = open (path, O_WRONLY | O_CREAT | O_EXCL, S_IWUSR | S_IRUSR);
|
|
if (m->lockfd == -1)
|
|
{
|
|
perror (path);
|
|
return -1;
|
|
}
|
|
if (do_lock (m->lockfd, F_WRLCK))
|
|
{
|
|
close (m->lockfd);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
maildir_unlock (mailbox_t * m)
|
|
{
|
|
char path[_POSIX_PATH_MAX];
|
|
|
|
snprintf (path, sizeof (path), "%s/isynclock", m->path);
|
|
unlink (path);
|
|
do_lock (m->lockfd, F_UNLCK);
|
|
close (m->lockfd);
|
|
}
|
|
|
|
/* open a maildir mailbox.
|
|
* if OPEN_FAST is set, 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.
|
|
* if OPEN_CREATE is set, we create the mailbox if it doesn't already exist.
|
|
*/
|
|
mailbox_t *
|
|
maildir_open (const char *path, int flags)
|
|
{
|
|
char buf[_POSIX_PATH_MAX];
|
|
DIR *d;
|
|
struct dirent *e;
|
|
message_t **cur;
|
|
message_t *p;
|
|
mailbox_t *m;
|
|
char *s;
|
|
int count = 0;
|
|
struct stat sb;
|
|
const char *subdirs[] = { "cur", "new", "tmp" };
|
|
int i;
|
|
datum key;
|
|
|
|
m = calloc (1, sizeof (mailbox_t));
|
|
m->lockfd = -1;
|
|
/* filename expansion happens here, not in the config parser */
|
|
m->path = expand_strdup (path);
|
|
|
|
if (stat (m->path, &sb))
|
|
{
|
|
if (errno == ENOENT && (flags & OPEN_CREATE))
|
|
{
|
|
if (mkdir (m->path, S_IRUSR | S_IWUSR | S_IXUSR))
|
|
{
|
|
fprintf (stderr, "ERROR: mkdir %s: %s (errno %d)\n",
|
|
m->path, strerror (errno), errno);
|
|
goto err;
|
|
}
|
|
|
|
for (i = 0; i < 3; i++)
|
|
{
|
|
snprintf (buf, sizeof (buf), "%s/%s", m->path, subdirs[i]);
|
|
if (mkdir (buf, S_IRUSR | S_IWUSR | S_IXUSR))
|
|
{
|
|
fprintf (stderr, "ERROR: mkdir %s: %s (errno %d)\n",
|
|
buf, strerror (errno), errno);
|
|
goto err;
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
fprintf (stderr, "ERROR: stat %s: %s (errno %d)\n", m->path,
|
|
strerror (errno), errno);
|
|
goto err;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* check to make sure this looks like a valid maildir box */
|
|
for (i = 0; i < 3; i++)
|
|
{
|
|
snprintf (buf, sizeof (buf), "%s/%s", m->path, subdirs[i]);
|
|
if (stat (buf, &sb))
|
|
{
|
|
fprintf (stderr, "ERROR: stat %s: %s (errno %d)\n", buf,
|
|
strerror (errno), errno);
|
|
fprintf (stderr,
|
|
"ERROR: %s does not appear to be a valid maildir style mailbox\n",
|
|
m->path);
|
|
goto err;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* we need a mutex on the maildir because of the state files that isync
|
|
* uses.
|
|
*/
|
|
if (maildir_lock (m))
|
|
goto err;
|
|
|
|
/* check for the uidvalidity value */
|
|
m->uidvalidity = read_uid (m->path, "isyncuidvalidity");
|
|
if (m->uidvalidity == (unsigned int) -1)
|
|
goto err;
|
|
|
|
/* load the current maxuid */
|
|
if ((m->maxuid = read_uid (m->path, "isyncmaxuid")) == (unsigned int) -1)
|
|
goto err;
|
|
|
|
if (flags & OPEN_FAST)
|
|
return m;
|
|
|
|
snprintf (buf, sizeof (buf), "%s/isyncuidmap", m->path);
|
|
m->db = dbm_open (buf, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
|
|
if (m->db == NULL)
|
|
{
|
|
fputs ("ERROR: unable to open UID db\n", stderr);
|
|
goto err;
|
|
}
|
|
|
|
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)
|
|
{
|
|
perror ("opendir");
|
|
goto err;
|
|
}
|
|
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);
|
|
|
|
/* determine the UID for this message. The basename (sans
|
|
* flags) is used as the key in the db
|
|
*/
|
|
strfcpy (buf, p->file, sizeof (buf));
|
|
s = strchr (p->file, ':');
|
|
if (s)
|
|
*s = 0;
|
|
key.dptr = buf;
|
|
key.dsize = strlen (buf);
|
|
key = dbm_fetch (m->db, key);
|
|
if (key.dptr)
|
|
{
|
|
p->uid = *(int *) key.dptr;
|
|
if (p->uid > m->maxuid)
|
|
m->maxuid = p->uid;
|
|
}
|
|
else
|
|
puts ("Warning, no UID for message");
|
|
|
|
if (s)
|
|
parse_info (p, s + 1);
|
|
if (p->flags & D_DELETED)
|
|
m->deleted++;
|
|
cur = &p->next;
|
|
}
|
|
closedir (d);
|
|
}
|
|
return m;
|
|
|
|
err:
|
|
if (m->db)
|
|
dbm_close (m->db);
|
|
if (m->lockfd != -1)
|
|
maildir_unlock (m);
|
|
free (m->path);
|
|
free (m);
|
|
return NULL;
|
|
}
|
|
|
|
/* 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;
|
|
}
|
|
|
|
int
|
|
maildir_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)
|
|
{
|
|
fputs ("ERROR: maxuid is now higher (fatal)\n", stderr);
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
maildir_close (mailbox_t * mbox)
|
|
{
|
|
if (mbox->db)
|
|
dbm_close (mbox->db);
|
|
|
|
/* release the mutex on the mailbox */
|
|
maildir_unlock (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);
|
|
}
|
|
|
|
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);
|
|
}
|