isync/sync.c

397 lines
9.7 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 <stdio.h>
#include <limits.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <sys/stat.h>
#include "isync.h"
static unsigned int MaildirCount = 0;
message_t *
find_msg (message_t * list, unsigned int uid)
{
for (; list; list = list->next)
if (list->uid == uid)
return list;
return 0;
}
static int
set_uid (DBM * db, const char *f, unsigned int uid)
{
char *s;
datum key, val;
key.dptr = (void *) f;
s = strchr (f, ':');
key.dsize = s ? (size_t) (s - key.dptr) : strlen (f);
val.dptr = (void *) &uid;
val.dsize = sizeof (uid);
dbm_store (db, key, val, DBM_REPLACE);
return 0;
}
int
sync_mailbox (mailbox_t * mbox, imap_t * imap, int flags,
unsigned int max_size, unsigned int max_msgs)
{
message_t *cur;
message_t *tmp;
char path[_POSIX_PATH_MAX];
char newpath[_POSIX_PATH_MAX];
char suffix[_POSIX_PATH_MAX];
char *p;
int fd;
int ret;
int fetched = 0;
int upload = 0;
unsigned int msg_count;
if (mbox->uidseen)
{
if (mbox->uidvalidity != imap->uidvalidity)
{
/* if the UIDVALIDITY value has changed, it means all our
* local UIDs are invalid, so we can't sync.
*/
fputs ("ERROR: UIDVALIDITY changed on server (fatal)\n", stderr);
return -1;
}
}
else if (maildir_set_uidvalidity (mbox, imap->uidvalidity))
{
fputs ("ERROR: unable to store UIDVALIDITY\n", stderr);
return -1;
}
if (mbox->maxuid == 0 || imap->maxuid > mbox->maxuid)
{
mbox->maxuid = imap->maxuid;
if (maildir_update_maxuid (mbox))
return -1;
}
/* if we are --fast mode, the mailbox wont have been loaded, so
* this next step is skipped.
*/
for (cur = mbox->msgs; cur; cur = cur->next)
{
tmp = find_msg (imap->msgs, cur->uid);
if (!tmp)
{
/* if this message wasn't fetched from the server, attempt to
* upload it
*/
if (cur->uid == (unsigned int) -1)
{
struct stat sb;
if ((cur->flags & D_DELETED) && (flags & SYNC_EXPUNGE))
{
/*
* This message is marked as deleted and we are
* expunging. Don't upload to the server.
*/
continue;
}
if ((flags & SYNC_QUIET) == 0)
{
if (!upload)
fputs ("Uploading messages", stdout);
fputc ('.', stdout);
fflush (stdout);
upload++;
}
/* upload the message if its not too big */
snprintf (path, sizeof (path), "%s/%s/%s", mbox->path,
cur->new ? "new" : "cur", cur->file);
if (stat (path, &sb))
{
perror (path);
continue; /* not fatal */
}
if (imap->box->max_size > 0
&& sb.st_size > imap->box->max_size)
{
if ((flags & SYNC_QUIET) == 0)
printf
("Warning, local message is too large (%lu), skipping...\n",
(unsigned long) sb.st_size);
continue;
}
fd = open (path, O_RDONLY);
if (fd == -1)
{
printf ("Error, unable to open %s: %s (errno %d)\n",
path, strerror (errno), errno);
continue;
}
cur->size = sb.st_size;
cur->uid = imap_append_message (imap, fd, cur);
/* if the server gave us back a uid, update the db */
if (cur->uid != (unsigned int) -1)
set_uid (mbox->db, cur->file, cur->uid);
close (fd);
}
/*
* message used to exist on server but no longer does (we know
* this beacause it has a UID associated with it).
*/
else if (flags & SYNC_DELETE)
{
cur->flags |= D_DELETED;
cur->dead = 1;
mbox->deleted++;
}
/* if the user doesn't want local msgs deleted when they don't
* exist on the server, warn that such messages exist.
*/
else if ((flags & SYNC_QUIET) == 0)
printf ("Warning, uid %u doesn't exist on server\n",
cur->uid);
continue;
}
tmp->processed = 1;
/* if the message is deleted, and CopyDeletedTo is set, and we
* are expunging, make a copy of the message now.
*/
if (((cur->flags | tmp->flags) & D_DELETED) != 0 &&
(flags & SYNC_EXPUNGE) && imap->box->copy_deleted_to)
{
if (imap_copy_message (imap, cur->uid,
imap->box->copy_deleted_to))
{
fprintf (stderr,
"ERROR: unable to copy deleted message to \"%s\"\n",
imap->box->copy_deleted_to);
return -1;
}
}
/* check if local flags are different from server flags.
* ignore \Recent and \Draft
*/
if (cur->flags != (tmp->flags & ~(D_RECENT | D_DRAFT)))
{
/* set local flags that don't exist on the server */
if (!(tmp->flags & D_DELETED) && (cur->flags & D_DELETED))
imap->deleted++;
imap_set_flags (imap, cur->uid, cur->flags & ~tmp->flags);
/* update local flags */
if ((cur->flags & D_DELETED) == 0 && (tmp->flags & D_DELETED))
mbox->deleted++;
cur->flags |= (tmp->flags & ~(D_RECENT | D_DRAFT));
/* don't bother renaming the file if we are just going to
* remove it later.
*/
if ((cur->flags & D_DELETED) == 0 || (flags & SYNC_EXPUNGE) == 0)
{
/* generate old path */
snprintf (path, sizeof (path), "%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 (newpath, sizeof (newpath), "%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 (path, newpath))
{
perror ("rename");
return -1;
}
else
{
/* update the filename in the msg struct */
p = strrchr (newpath, '/');
free (cur->file);
cur->file = strdup (p + 1);
cur->new = 0; /* not any more */
}
}
}
}
if (upload)
fprintf (stdout, " %d messages.\n", upload);
if ((flags & SYNC_QUIET) == 0)
{
fputs ("Fetching new messages", stdout);
fflush (stdout);
}
if (max_msgs == 0)
max_msgs = UINT_MAX;
else
{
/* expire messages in excess of the max-count for this mailbox.
* flagged mails are considered sacrosant and not deleted.
* we have already done the upload to the server, so messing with
* the flags variable do not have remote side effects.
*/
for (cur = imap->msgs, msg_count = 0;
cur && msg_count < max_msgs; cur = cur->next, msg_count++)
{
tmp = find_msg (mbox->msgs, cur->uid);
if (tmp)
tmp->wanted = 1;
}
for (cur = mbox->msgs; cur; cur = cur->next)
{
if (!cur->wanted && !(cur->flags & D_FLAGGED))
{
cur->flags |= D_DELETED;
cur->dead = 1;
mbox->deleted++;
}
}
}
for (cur = imap->msgs, msg_count = 0;
cur && msg_count < max_msgs; cur = cur->next, msg_count++)
{
if (!cur->processed)
{
/* new message on server */
if ((flags & SYNC_EXPUNGE) && (cur->flags & D_DELETED))
{
/* this message has been marked for deletion and
* we are currently expunging a mailbox. don't
* bother downloading this message
*/
continue;
}
if (max_size && cur->size > max_size)
{
if ((flags & SYNC_QUIET) == 0)
printf
("Warning, message skipped because it is too big (%u)\n",
cur->size);
continue;
}
/* construct the flags part of the file name. */
*suffix = 0;
if (cur->flags & ~D_RECENT)
{
snprintf (suffix, sizeof (suffix), ":2,%s%s%s%s",
(cur->flags & D_FLAGGED) ? "F" : "",
(cur->flags & D_ANSWERED) ? "R" : "",
(cur->flags & D_SEEN) ? "S" : "",
(cur->flags & D_DELETED) ? "T" : "");
}
for (;;)
{
/* create new file */
snprintf (path, sizeof (path), "%s/tmp/%ld_%d.%d.%s%s",
mbox->path, time (0), MaildirCount++, getpid (),
Hostname, suffix);
if ((fd = open (path, O_WRONLY | O_CREAT | O_EXCL, 0600)) > 0)
break;
if (errno != EEXIST)
{
perror (path);
break;
}
sleep (2);
}
if (fd < 0)
continue;
if ((flags & SYNC_QUIET) == 0)
{
/* give some visual feedback that something is happening */
fputs (".", stdout);
fflush (stdout);
}
fetched++;
ret = imap_fetch_message (imap, cur->uid, fd);
if (fsync (fd))
{
perror ("fsync");
close (fd);
}
else if (close (fd))
perror ("close");
else if (!ret)
{
p = strrchr (path, '/');
snprintf (newpath, sizeof (newpath), "%s/%s%s", mbox->path,
(cur->flags & ~D_RECENT) ? "cur" : "new", p);
/* its ok if this fails, the next time we sync the message
* will get pulled down
*/
if (link (path, newpath))
perror ("link");
else
{
/* update the db with the UID mapping for this file */
set_uid (mbox->db, p + 1, cur->uid);
}
}
/* always remove the temp file */
unlink (path);
}
}
if ((flags & SYNC_QUIET) == 0)
printf (" %d messages\n", fetched);
return 0;
}